def keyboardCommands(self):
# get current key
currentKey = self.keyboard.getKey()
if DEBUG and (currentKey == ord('s') or currentKey == ord('S')):
logger.debug("Current status: " + str(self.status))
# press P to find parking lot
if currentKey == ord('p') or currentKey == ord('P'):
logger.info("Looking for a parking lot")
self.setStatus(Status.SEARCHING_PARK)
# press M to manual control
elif currentKey == ord('m') or currentKey == ord('M'):
logger.info("Manual")
self.setStatus(Status.MANUAL)
# press A to auto control
elif currentKey == ord('a') or currentKey == ord('A'):
logger.info("Auto")
self.setStatus(Status.FORWARD)
# return current key to allow other controls
return currentKey
def __init__(self):
# initialize devices
self.initializeDevices()
# initial speed and steering angle values
self.speed = 0.0
self.angle = 0.0
# initial wheel length used to calculate how many m the wheels have traveled
self.leftWheelDistance = 0.0
self.rightWheelDistance = 0.0
self.updateDistanceTraveled()
# line forwared
self.lineFollower = LineFollower(self.camera)
# navigation
self.nav = PathPlanner()
self.nav.setRobotPosition(Position(4, 1))
self.nav.setGoalPosition(Position(14, 22))
self.nav.setRobotOrientation(SOUTH)
self.nav.printStatus()
# compute fastest route from robot to goal
self.turns = self.nav.getFastestRoute()
logger.debug("turns: " + str(self.turns))
# odometry
self.odometry = Odometry(self.positionSensors, self.compass,
self.nav.getRobotPosition(),
self.nav.getRobotOrientation())
def updateCollisionAvoidance(self):
if self.collisionAvoidance.isEnabled():
newSpeed = self.collisionAvoidance.getSpeed()
newAngle = self.collisionAvoidance.getSteeringAngle()
logger.debug("Collision Avoidance - Speed: " + str(newSpeed) +
" Angle: " + str(newAngle))
self.setAngleAndSpeed(newAngle, newSpeed)
def update_repo(self):
"""
Updates repo to latest version of set branch.
i.e, calls:
$>_git pull
$>_git submodule update --init
Raises:
None
Returns:
(Boolean): True if update succeeded, otherwise False
"""
logger.debug('Running git pull on %s',)
acc_rc = 0
rc, _ = self._git('pull --recurse-submodules=yes', with_errno=True)
acc_rc = acc_rc | rc
logger.debug('_git pull done...')
rc, _ = self._git('submodule update --init', with_errno=True)
acc_rc = acc_rc | rc
if rc != 0:
return False
else:
return True
def fill(self):
other_item_with_same_email_url = SenderMetadata.get(SenderMetadata.email_url == self.email_url)
if other_item_with_same_email_url:
self.party = other_item_with_same_email_url.party
self.state = other_item_with_same_email_url.state
if not (self.party or self.state):
print(t.yellow(self.email_url))
if not self.party:
acceptable_answers = ["d", "r", "i"]
# self.party = get_answer("Enter Party (d/r/i)", acceptable_answers)
self.party = "d"
if not self.state:
acceptable_answers = ["ak", "al", "ar", "az", "ca",
"co", "ct", "de", "fl", "ga", "hi", "ia", "id", "il",
"in", "ks", "ky", "la", "ma", "md", "me", "mi", "mn",
"mo", "ms", "mt", "nc", "nd", "ne", "nh", "nj", "nm",
"nv", "ny", "oh", "ok", "or", "pa", "ri", "sc", "sd",
"tn", "tx", "ut", "va", "vt", "wa", "wi", "wv", "wy"]
negations = ["-1", "none", "n"]
acceptable_answers += negations
# state = get_answer("Enter State Abbreviation", acceptable_answers)
# self.state = state.lower() if state in negations else "-1"
self.state = "-1"
logger.debug("Filled SenderMetadata for %s", self.email_address)
self.save()
def fill(self):
other_item_with_same_email_url = SenderMetadata.get(SenderMetadata.email_url == self.email_url)
if other_item_with_same_email_url:
self.party = other_item_with_same_email_url.party
self.state = other_item_with_same_email_url.state
if not (self.party or self.state):
print t.yellow(self.email_url)
if not self.party:
acceptable_answers = ["d", "r", "i"]
self.party = get_answer("Enter Party (d/r/i)", acceptable_answers)
# self.party = "d"
if not self.state:
acceptable_answers = ["ak", "al", "ar", "az", "ca",
"co", "ct", "de", "fl", "ga", "hi", "ia", "id", "il",
"in", "ks", "ky", "la", "ma", "md", "me", "mi", "mn",
"mo", "ms", "mt", "nc", "nd", "ne", "nh", "nj", "nm",
"nv", "ny", "oh", "ok", "or", "pa", "ri", "sc", "sd",
"tn", "tx", "ut", "va", "vt", "wa", "wi", "wv", "wy"]
negations = ["-1", "none", "n"]
acceptable_answers += negations
state = get_answer("Enter State Abbreviation", acceptable_answers)
self.state = state.lower() if state in negations else "-1"
# self.state = "-1"
logger.debug("Filled SenderMetadata for %s", self.email_address)
self.save()
def updateManualDrive(self):
if self.manualDrive.isEnabled():
newSpeed = self.manualDrive.getSpeed()
newAngle = self.manualDrive.getAngle()
logger.debug("Manual Drive - Speed: " + str(newSpeed) +
" Angle: " + str(newAngle))
self.setAngleAndSpeed(newAngle, newSpeed)
def update_repo(self):
"""
Updates repo to latest version of set branch.
i.e, calls:
$>_git pull
$>_git submodule update --init
Raises:
None
Returns:
(Boolean): True if update succeeded, otherwise False
"""
logger.debug('Running git pull on %s', )
acc_rc = 0
rc, _ = self._git('pull --recurse-submodules=yes', with_errno=True)
acc_rc = acc_rc | rc
logger.debug('_git pull done...')
rc, _ = self._git('submodule update --init', with_errno=True)
acc_rc = acc_rc | rc
if rc != 0:
return False
else:
return True
def updateParking(self):
if self.parking.isEnabled():
newSpeed = self.parking.getSpeed()
newAngle = self.parking.getAngle()
logger.debug("Parking - Speed: " + str(newSpeed) + " Angle: " +
str(newAngle))
self.setAngleAndSpeed(newAngle, newSpeed)
def updatePathRunner(self):
if self.pathRunner.isEnabled():
newSpeed = self.pathRunner.getSpeed()
newAngle = self.pathRunner.getSteeringAngle()
logger.debug("Path Runner - Speed: " + str(newSpeed) + " Angle: " +
str(newAngle))
if self.pathRunner.isGoalReach():
self.pathRunner.disable()
self.parking.enable()
self.setAngleAndSpeed(newAngle, newSpeed)
def find_matching_maintainers(self, filename):
"""
Searches for any maintainer responsible for filename
Really not happy with this implementation, basically does a linear search finding matches.
Should instead be implemented using radix tree..
Args:
filename(str): name of the file to check responsibility for
Returns:
matching_maintainer(list): entry(dict):
entry['subsystem'](str)
entry['maintainer'](list(str))
entry['maillist'](str)
entry['status'](str)
entry['file-include-pattern'](list(str))
entry['file-exclude-pattern'](list(str))
Raises:
None
"""
matching_maintainers = []
for maintainer in self.get_maintainer_list():
do_exclude = False
# First check exclude pattern
for exclpattern in maintainer['file-exclude-pattern']:
if exclpattern[-1:] == '/': # Handle this like a catch-all recursive directory rule
if filename.startswith(exclpattern):
do_exclude = True
logger.debug('Excluding "%s" based on, rule=%s', maintainer['subsystem'], exclpattern)
else:
if fnmatch(filename, exclpattern):
do_exclude = True
logger.debug('Excluding "%s" based on, rule=%s', maintainer['subsystem'], exclpattern)
# Then check include pattern
if do_exclude is False:
for inclpattern in maintainer['file-include-pattern']:
if filename[1] == '/': # Handle this as an absolute path
if filename.endswith(inclpattern):
logger.debug('Found match for "%s", rule=%s', maintainer['subsystem'], inclpattern)
matching_maintainers.append(maintainer)
elif inclpattern[-1:] == '/': # Handle this like a catch-all recursive directory rule
if inclpattern in filename:
logger.debug('Found match for "%s", rule=%s', maintainer['subsystem'], inclpattern)
matching_maintainers.append(maintainer)
elif fnmatch(filename, inclpattern):
logger.debug('Found match for "%s", rule=%s', maintainer['subsystem'], inclpattern)
matching_maintainers.append(maintainer)
return matching_maintainers
def run_lizard(filename,
symbolic_filename_translator=lambda file_: file_,
filecontent=None):
'''
Runs lizard with the possibility of using a symbolic file translation
Explanation of terms:
'nloc': non-commented lines of code (commonly known as source-line-of-code)
Note that this is NOT the same definition as used everywhere else in the maintainer_scripts
where nloc means number-of-lines-of-code (i.e every single line, regardless of being comments or not).
'token_count': Number of tokens (number of words)
'parameter_count': Number of arguments passed to function
Args:
filename(str): The file to be analyzed, if filecontent != None, file will be read.
filecontent(str): If not None, this str will be used for analysis instead
Returns:
functions[dict]: All functions, including global scope (empty string)
'name'(str)': function name (global scope is called "")
'nloc'(int)': nloc for function
'cyclomatic_complexity(int)': mccabes cyclomatic complexity
'token_count'(int)': #tokens in function
'parameter_count'(int)': #parematers passed to function
'start_line'(int): starting linenumber of function
'end_line'(int): ending linenumber of function
If parsing fails an empty list will be returned
'''
if filecontent is None:
with open(filename) as f:
filecontent = f.read()
fa = _SymbolicFileAnalyzer(extensions=lizard.get_extensions([]))
lizard_object = fa.analyze_file(symbolic_filename_translator(filename),
filecontent)
if lizard_object:
logger.debug("Parsed file %s ", os.path.basename(filename))
return [func.__dict__ for func in lizard_object.function_list]
else:
logger.debug("Unable to parse file %s", os.path.basename(filename))
return []
def find_all_files_in_srcroots(self, max_number_of_files=None):
"""
Finds all files within the folders and files defined by the src-root-file
Args:
None
Returns:
files(list): sorted list of all files
Raises:
None
"""
all_files = []
for path in self._srcroots_include:
logger.debug("searching path:%s", path)
files = self._get_all_files_in_path(path, max_number_of_files)
files.sort() # a little bit more efficient than sorted()
all_files.extend(files)
if max_number_of_files is not None and len(all_files) >= max_number_of_files:
break
return all_files
def find_all_files_in_srcroots(self, max_number_of_files=None):
"""
Finds all files within the folders and files defined by the src-root-file
Args:
None
Returns:
files(list): sorted list of all files
Raises:
None
"""
all_files = []
for path in self._srcroots_include:
logger.debug("searching path:%s", path)
files = self._get_all_files_in_path(path, max_number_of_files)
files.sort() # a little bit more efficient than sorted()
all_files.extend(files)
if max_number_of_files is not None and len(
all_files) >= max_number_of_files:
break
return all_files
def getFastestRoute(self):
# update map status, this ensure new obstacles are detected
self.updateMap()
logger.debug("Path from: " + str(self.robotPosition) + " to " + str(self.goalPosition) + " Initial Orientation: " + str(self.robotOrientation))
# get fastest route from AStar giving map, start position and goal position
route = AStar.findPath(self.map, self.robotPosition.getPositionArray(), self.goalPosition.getPositionArray())
# if no route was found, return UNKNOWN path
if route == None:
return UNKNOWN
# get only intersection nodes from AStar route
intersections = self.getIntersectionNodesFromRoute(route)
# get cardinal points directions based on intersection nodes
directions = self.getDirectionsFromIntersections(intersections)
logger.debug(directions)
# get turns based on robot directions and robot orientation
turns = self.getTurnsFromDirections(directions)
logger.debug(turns)
# remove curve turns
turns = self.removeCurves(turns, intersections)
# return the turns
return turns
def run_lizard(filename, symbolic_filename_translator=lambda file_: file_, filecontent=None):
'''
Runs lizard with the possibility of using a symbolic file translation
Explanation of terms:
'nloc': non-commented lines of code (commonly known as source-line-of-code)
Note that this is NOT the same definition as used everywhere else in the maintainer_scripts
where nloc means number-of-lines-of-code (i.e every single line, regardless of being comments or not).
'token_count': Number of tokens (number of words)
'parameter_count': Number of arguments passed to function
Args:
filename(str): The file to be analyzed, if filecontent != None, file will be read.
filecontent(str): If not None, this str will be used for analysis instead
Returns:
functions[dict]: All functions, including global scope (empty string)
'name'(str)': function name (global scope is called "")
'nloc'(int)': nloc for function
'cyclomatic_complexity(int)': mccabes cyclomatic complexity
'token_count'(int)': #tokens in function
'parameter_count'(int)': #parematers passed to function
'start_line'(int): starting linenumber of function
'end_line'(int): ending linenumber of function
If parsing fails an empty list will be returned
'''
if filecontent is None:
with open(filename) as f:
filecontent = f.read()
fa = _SymbolicFileAnalyzer(extensions=lizard.get_extensions(['nd', 'io']))
lizard_object = fa.analyze_file(symbolic_filename_translator(filename), filecontent)
if lizard_object:
logger.debug("Parsed file %s ", os.path.basename(filename))
return [func.__dict__ for func in lizard_object.function_list]
else:
logger.debug("Unable to parse file %s", os.path.basename(filename))
return []
def getNearestWalkablePosition(position, orientation):
if not isWalkable(position):
logger.debug("Actual position non walkable. " + str(position) + " is unwalkable")
x = position.getX()
y = position.getY()
logger.debug("ORIENTATION: " + str(orientation))
if orientation == Orientation.NORD or orientation == Orientation.SOUTH:
p = Position(x, y - 1)
if isWalkable(p):
return p
p = Position(x, y + 1)
if isWalkable(p):
return p
elif orientation == Orientation.EAST or orientation == Orientation.WEST:
p = Position(x - 1, y)
if isWalkable(p):
return p
p = Position(x + 1, y)
if isWalkable(p):
return p
else:
return position
def list_message_ids():
"""
Returns a list of all gmail message ids for the authenticated email account.
"""
# Get first page
logger.debug("Getting first page of message ids")
request = gmail_service.users().messages().list(userId='me')
response = request.execute()
messages_json = response['messages']
# Get remaining pages
page_no = 1
while response.get('nextPageToken'):
page_no += 1
logger.debug("Getting page %d of message ids" % page_no)
request = gmail_service.users().messages().list_next(
previous_request=request, previous_response=response)
response = request.execute()
messages_json += response['messages']
message_ids = map(lambda x: x['id'], messages_json)
return message_ids
def computePositionBasedOnLandmark(self):
# if the line get lost provably the robot is near an intersecion
isLineLost = self.lineFollower.isLineLost()
logger.debug("isLineLost: " + str(isLineLost) + " isLineAlreadyLost: " + str(self.lineAlreadyLost))
if isLineLost and not self.lineAlreadyLost:
self.lineAlreadyLost = True
nearestIntersecion = Map.findNearestIntersection(self.position)
offset = 0.25
if nearestIntersecion != -1:
x = nearestIntersecion.getX()
y = nearestIntersecion.getY()
if self.orientation == Orientation.NORD:
nearestIntersecion.setX(x + offset)
if self.orientation == Orientation.EAST:
nearestIntersecion.setY(y - offset)
if self.orientation == Orientation.SOUTH:
nearestIntersecion.setX(x - offset)
if self.orientation == Orientation.WEST:
nearestIntersecion.setY(y + offset)
self.position = nearestIntersecion
elif not isLineLost:
self.lineAlreadyLost = False
def getNearestWalkablePositionEquals(position, orientation, value):
if not isWalkable(position):
logger.debug("Actual position non walkable. " + str(position) + " is unwalkable")
x = position.getX()
y = position.getY()
if orientation == Orientation.NORD or orientation == Orientation.SOUTH:
p = Position(x+1, y)
if isWalkable(p) and getValue(p) == value:
return p
p = Position(x-1, y)
if isWalkable(p) and getValue(p) == value:
return p
elif orientation == Orientation.EAST or orientation == Orientation.WEST:
p = Position(x, y+1)
if isWalkable(p) and getValue(p) == value:
return p
p = Position(x, y-1)
if isWalkable(p) and getValue(p) == value:
return p
elif getValue(position) == value:
return position
else:
return -1
def _lookup_maintainers(pool, db, maintainerobj):
logger.info("Updating maintainers...")
with db.get_session() as session:
file_tuples = db.get_file_ids_and_abspaths(session)
logger.debug("Remove subsystem mappings..")
for file_ in session.query(File):
file_.subsystem = None
session.commit()
Subsystem.__table__.drop(db.engine, checkfirst=True)
Subsystem.__table__.create(db.engine, checkfirst=False)
logger.debug("Populating maintainers table...")
for maintainer_info in maintainerobj.get_maintainer_list():
db.insert_subsystem_entry(
session,
subsystem=maintainer_info["subsystem"],
status=maintainer_info["status"],
maintainers=[
maint for maint, _ in maintainer_info["maintainer"]
])
session.commit()
logger.debug("Looking up maintainer for all files")
filemap = zip([maintainerobj] * len(file_tuples), file_tuples)
count_some_maintainer = 0
iter_ = FancyBar(max=len(filemap)).iter(
pool.imap_unordered(worker(_get_maintainers), filemap))
for file_tuple, maintainer_dicts in iter_:
if maintainer_dicts is not None:
count_some_maintainer += 1
file_id = file_tuple[0]
for maintainer_dict in maintainer_dicts:
db.update_file_entry(
session,
file_id=file_id,
subsystem_name=maintainer_dict["subsystem"])
session.commit()
logger.info("Amount of files with a maintainer: %d",
count_some_maintainer)
logger.info("Amount of files without a maintainer: %d",
len(file_tuples) - count_some_maintainer)
def _lookup_maintainers(pool, db, maintainerobj):
logger.info("Updating maintainers...")
with db.get_session() as session:
file_tuples = db.get_file_ids_and_abspaths(session)
logger.debug("Remove subsystem mappings..")
for file_ in session.query(File):
file_.subsystem = None
session.commit()
Subsystem.__table__.drop(db.engine, checkfirst=True)
Subsystem.__table__.create(db.engine, checkfirst=False)
logger.debug("Populating maintainers table...")
for maintainer_info in maintainerobj.get_maintainer_list():
db.insert_subsystem_entry(
session,
subsystem=maintainer_info["subsystem"],
status=maintainer_info["status"],
maintainers=[maint for maint, _ in maintainer_info["maintainer"]],
)
session.commit()
logger.debug("Looking up maintainer for all files")
filemap = zip([maintainerobj] * len(file_tuples), file_tuples)
count_some_maintainer = 0
iter_ = FancyBar(max=len(filemap)).iter(pool.imap_unordered(worker(_get_maintainers), filemap))
for file_tuple, maintainer_dicts in iter_:
if maintainer_dicts is not None:
count_some_maintainer += 1
file_id = file_tuple[0]
for maintainer_dict in maintainer_dicts:
db.update_file_entry(session, file_id=file_id, subsystem_name=maintainer_dict["subsystem"])
session.commit()
logger.info("Amount of files with a maintainer: %d", count_some_maintainer)
logger.info("Amount of files without a maintainer: %d", len(file_tuples) - count_some_maintainer)
def _lookup_metrics(pool, walker, vcs, db, files, last_update, config_transformerdict):
logger.info("Looking up metrics...")
file_map = zip([vcs] * len(files), [last_update] * len(files), files)
version_map = []
logger.info(" Looking up all VCS versions...")
iter_ = FancyBar(max=len(file_map)).iter(pool.imap_unordered(worker(_get_lsv), file_map))
for file_, contributions in iter_:
for contrib_index, contrib in enumerate(contributions):
prev_version = contributions[contrib_index - 1]["version"] if contrib_index > 0 else None
filext = os.path.splitext(file_)[1]
version_map.append((file_, contrib, prev_version, vcs, config_transformerdict.get(filext, None)))
logger.info(" Looking up all metrics...")
with db.get_session() as session:
iter_ = FancyBar(max=len(version_map)).iter(pool.imap_unordered(worker(_get_metrics), version_map))
for file_, contrib in iter_:
"""
Results are coming in, insert results into database
We avoid doing this inside the process pool due to that sqlite is not threadsafe
"""
version = contrib["version"]
date_ = contrib["datetime"]
user = _translate_username(contrib)
translated_file = walker.translate_env(file_)
complexity = contrib["complexity"]
changerates = contrib["changerates"]
for function, (added, changed, deleted, nloc) in changerates.iteritems():
if function not in complexity:
if file_.endswith((".c", ".cc", ".cpp", ".h", ".hpp")):
logger.debug("%s Could not find complexity function %s", file_, function)
logger.debug("%s Available functions:", os.path.basename(file_))
for func in complexity.iterkeys():
logger.debug("%s", func)
cyclomatic_complexity = None
tokens = None
parameter_count = None
else:
cyclomatic_complexity, tokens, parameter_count, max_nd, fin, fout = complexity[function]
db.insert_change_metric(
session,
file_=translated_file,
version=version,
function=function,
date_=date_,
user=user,
added=added,
changed=changed,
deleted=deleted,
nloc=nloc,
cyclomatic_complexity=cyclomatic_complexity,
token_count=tokens,
parameter_count=parameter_count,
max_nesting_depth=max_nd,
fan_in=fin,
fan_out=fout,
)
session.commit()
def updateSpeedAndAngle(self):
isLineLost = self.lineFollower.isLineLost()
currentPath = self.currentPath
logger.debug("Current Status: " + str(self.status) + " prev Status: " +
str(self.prevStatus))
lineFollowerAngle = self.lineFollower.getNewSteeringAngle()
if currentPath != UNKNOWN and self.actualTurn == 0:
if self.currentPath[self.actualTurn] == U_TURN:
self.setStatus(U_TURN)
self.actualTurn += 1
elif self.status == FOLLOW_LINE:
self.steeringAngle = lineFollowerAngle
if self.isGoalReach():
self.setStatus(STOP)
if isLineLost and currentPath == UNKNOWN:
self.speed = 0.0
elif isLineLost and currentPath != UNKNOWN and Map.findNearestIntersection(
self.positioning.getPosition(), 1) != -1:
#if self.prevStatus != SEARCH_LINE:
self.setStatus(TURN)
elif isLineLost and Map.findNearestIntersection(
self.positioning.getPosition()) == -1:
self.setStatus(SEARCH_LINE)
elif self.status == TURN:
if currentPath != UNKNOWN and self.actualTurn < len(currentPath):
turn = currentPath[self.actualTurn]
self.steeringAngle = 0.57 * turn
else:
self.currentPath = UNKNOWN
if not isLineLost:
self.actualTurn += 1
self.setStatus(FOLLOW_LINE)
elif self.status == SEARCH_LINE:
self.steeringAngle = self.lineFollower.getSteeringAngleLineSearching(
)
if not isLineLost:
logger.debug("Line was lost and i found it!")
self.setStatus(FOLLOW_LINE)
threshold = 500
angle = 0.5
logger.debug("FRONT LEFT: ")
if self.distanceSensors.frontLeft.getValue() > threshold:
self.lineFollower.resetLastLineKnownZone(angle)
elif self.distanceSensors.frontRight.getValue() > threshold:
self.lineFollower.resetLastLineKnownZone(-angle)
elif self.status == U_TURN:
logger.debug("Actual orientation: " +
str(self.positioning.getOrientation()) +
" goal orientation: " +
str(self.uTurnGoalOrientation))
self.sensors = self.distanceSensors
logger.debug("U_TURN: Status: " + str(self.uTurnStatus))
if self.uTurnStatus == UNKNOWN:
# check if we can do U turn
self.uTurnStatus = 1
self.steeringAngle = 1
self.uTurnGoalOrientation = Orientation(
(self.positioning.inaccurateOrientation + 2) % 4)
if self.uTurnStatus == 1:
if self.sensors.frontDistance(
950) or self.positioning.getOrientation() == (
(self.uTurnGoalOrientation + 1) %
4) or self.positioning.getOrientation() == (
(self.uTurnGoalOrientation - 1) % 4):
logger.debug(
"U_TURN: First step complete, going back (Status 1)")
self.speed = -0.2
self.steeringAngle = -1 * self.steeringAngle
self.uTurnStatus = 3
self.uTurnStartingMeter = self.positioning.getActualDistance(
)
else:
self.speed = 0.2
self.steeringAngle = 1
elif self.uTurnStatus == 2:
if self.sensors.frontDistance(950):
logger.debug(
"U_TURN: First step complete, going back (status 2)")
self.speed = -0.2
self.steeringAngle = -1 * self.steeringAngle
self.uTurnStatus += 1
self.uTurnStartingMeter = self.positioning.getActualDistance(
)
if self.positioning.getOrientation(
) == self.uTurnGoalOrientation:
self.uTurnStatus += 2
elif self.uTurnStatus == 3:
if self.sensors.backDistance(950):
logger.debug(
"U_TURN: Obstacle founded behind, going forward")
self.speed = 0.2
self.steeringAngle = -1 * self.steeringAngle
self.uTurnStatus -= 1
if self.positioning.getOrientation(
) == self.uTurnGoalOrientation:
self.uTurnStatus += 1
else:
logger.debug("U_TURN: Maneuver complete")
logger.debug("U_TURN: Distance: " +
str(self.positioning.getActualDistance() -
self.uTurnStartingMeter))
distanzaPercorsa = self.positioning.getActualDistance(
) - self.uTurnStartingMeter
if distanzaPercorsa >= 0:
self.steeringAngle = -0.5 * self.steeringAngle
elif abs(distanzaPercorsa) > 0.07:
self.steeringAngle = -0.1 * self.steeringAngle
else:
self.steeringAngle = -0.2 * self.steeringAngle
# if Map.getValue(self.positioning.getPosition()) == Map.C:
self.steeringAngle *= -5
logger.debug("U_TURN: Distance: " + str(distanzaPercorsa) +
", sterring angle: " + str(self.steeringAngle))
self.speed = 0.5
self.uTurnStatus = UNKNOWN
self.uTurnGoalOrientation = UNKNOWN
self.uTurnStartingMeter = UNKNOWN
self.lineFollower.resetLastLineKnownZone(self.steeringAngle)
self.setStatus(SEARCH_LINE)
elif self.status == STOP:
self.speed = 0.0
logger.info("Destination Reached")
# logger.debug("Steerign angle: " + str(self.steeringAngle) + " STATUS: " + str(self.status))
elif self.isGoalReach() and isLineLost and currentPath == UNKNOWN:
self.speed = 0.0
elif not isLineLost:
self.steeringAngle = self.lineFollower.getNewSteeringAngle()
# self.actualTurn += 1
elif isLineLost and currentPath != UNKNOWN:
if self.actualTurn < len(currentPath):
turn = currentPath[self.actualTurn]
self.steeringAngle = 0.5 * turn
# what if U_TURN? Return it to motion to make u_turn?
else:
currentPath = UNKNOWN
elif isLineLost and currentPath == UNKNOWN:
# self.speed = 0.0
pass
def goTo(self, goal):
self.pathPlanner.setGoalPosition(goal)
self.currentPath = self.pathPlanner.getFastestRoute()
logger.debug("Current Path to Goal: " + str(self.currentPath))
def computeSpeedAndAngle(self):
# set values of thresholds
tolerance = 10
frontThreshold = 700
frontSideThreshold = 620
sideThreshold = 800
# logging distance sensors
logger.debug("SL: " + str(self.sl) + " SR: " + str(self.sr))
logger.debug("FL: " + str(self.fl) + " FR: " + str(self.fr) + " FC: " +
str(self.fc))
logger.debug("BL: " + str(self.bl) + " BR: " + str(self.br) + " BC: " +
str(self.bc))
# if collission imminent lowering the tolerance
if self.fc > frontThreshold:
tolerance = 0
else:
tolerance = 10
# if front obstacle reduce speed
if self.fc > 750:
self.speed = 0.2
else:
self.speed = 0.5
# if no way to escape, obstacle is detected
if self.fl > 850 and self.fr > 850 or self.fc > 850:
logger.debug("Obstacle Detected!")
self.obstacleDetected = True
else:
self.obstacleDetected = False
# check if front left obstacle, turn right
if self.fl > self.fr + tolerance and (self.fl > frontSideThreshold
or self.fc > frontThreshold):
# self.steeringAngle += (self.fl - self.fr) / 500.0
self.steeringAngle = RIGHT * (self.fl / 2000.0 +
(self.fl - self.fr) / 2000.0)
# logger.debug("Steering angle: " + str(RIGHT * frontLeftSensor / 1000.0 * MAX_ANGLE))
self.collisionDetected = True
# logger.debug("Steering angle (FRONT LEFT): " + str(self.steeringAngle))
# check if front right obstacle, turn left
elif self.fr > self.fl + tolerance and (self.fr > frontSideThreshold
or self.fc > frontThreshold):
# self.steeringAngle -= (self.fl - self.fr) / 500.0
self.steeringAngle = LEFT * (self.fr / 2000.0 +
(self.fr - self.fl) / 2000.0)
# logger.debug("Steering angle: " + str(LEFT * frontRightSensor / 1000.0 * MAX_ANGLE))
self.collisionDetected = True
# logger.debug("Steering angle (FRONT RIGHT): " + str(self.steeringAngle))
# check if side left obstacle, turn slight right
elif self.sl > sideThreshold:
self.steeringAngle = RIGHT * self.sl / 3000.0
self.collisionDetected = True
# check if side right obstacle, turn slight left
elif self.sr > sideThreshold:
self.steeringAngle = LEFT * self.sr / 3000.0
self.collisionDetected = True
# if no obstacle go straight
else:
self.steeringAngle = self.steeringAngle / 1.5
self.collisionDetected = False
# maxing out the steerign angle
if self.steeringAngle > 1:
self.steeringAngle = 1
if self.steeringAngle < -1:
self.steeringAngle = -1
# reduce speed if collision detected
if self.collisionDetected:
self.speed = 0.3
def _lookup_metrics(pool, walker, vcs, db, files, last_update,
config_transformerdict):
logger.info("Looking up metrics...")
file_map = zip([vcs] * len(files), [last_update] * len(files), files)
version_map = []
logger.info(" Looking up all VCS versions...")
iter_ = FancyBar(max=len(file_map)).iter(
pool.imap_unordered(worker(_get_lsv), file_map))
for file_, contributions in iter_:
for contrib_index, contrib in enumerate(contributions):
prev_version = contributions[
contrib_index - 1]['version'] if contrib_index > 0 else None
filext = os.path.splitext(file_)[1]
version_map.append((file_, contrib, prev_version, vcs,
config_transformerdict.get(filext, None)))
logger.info(" Looking up all metrics...")
with db.get_session() as session:
iter_ = FancyBar(max=len(version_map)).iter(
pool.imap_unordered(worker(_get_metrics), version_map))
for file_, contrib in iter_:
'''
Results are coming in, insert results into database
We avoid doing this inside the process pool due to that sqlite is not threadsafe
'''
version = contrib['version']
date_ = contrib['datetime']
user = _translate_username(contrib)
translated_file = walker.translate_env(file_)
complexity = contrib['complexity']
changerates = contrib['changerates']
for function, (added, changed, deleted,
nloc) in changerates.iteritems():
if function not in complexity:
if file_.endswith((".c", ".cc", ".cpp", ".h", ".hpp")):
logger.debug(
"%s Could not find complexity function %s", file_,
function)
logger.debug("%s Available functions:",
os.path.basename(file_))
for func in complexity.iterkeys():
logger.debug("%s", func)
cyclomatic_complexity = None
tokens = None
parameter_count = None
else:
cyclomatic_complexity, tokens, parameter_count = complexity[
function]
db.insert_change_metric(
session,
file_=translated_file,
version=version,
function=function,
date_=date_,
user=user,
added=added,
changed=changed,
deleted=deleted,
nloc=nloc,
cyclomatic_complexity=cyclomatic_complexity,
token_count=tokens,
parameter_count=parameter_count)
session.commit()
def printStatus(self):
logger.debug("Orientation: " + str(self.orientation) + " - Positioning: " + str(self.position))
def update(self):
self.updateExternalController()
collisionImminent = False
isUTurning = self.pathRunner.isUTurning()
isParking = self.parking.isParking()
isParked = self.parking.isParked()
isSearchingPark = self.parking.isSearchingPark()
isManualActive = self.manualDrive.isEnabled()
isGoalReached = self.pathRunner.isGoalReach()
collisionImminent = self.collisionAvoidance.isCollisionDetected()
obstacleDetected = self.collisionAvoidance.isObstacleDetected()
logger.debug("collissionImminent: " + str(collisionImminent) +
" obstacleDetected: " + str(obstacleDetected) +
" isUTurning: " + str(isUTurning))
if self.status == PATH_FOLLOWING:
logger.debug("MOTION: PathFollowing")
self.updatePathRunner()
# During path find a object that can be avoid
if collisionImminent and not isUTurning:
self.setStatus(COLLISION_AVOIDANCE)
if isGoalReached:
self.parking.enable()
self.setStatus(PARKING)
elif self.status == PARKING:
logger.debug("MOTION: Parking")
self.updateParking()
if isParked:
self.setStatus(STOP)
# During parking find a object that can be avoid
if collisionImminent and isSearchingPark:
self.setStatus(COLLISION_AVOIDANCE)
elif self.status == COLLISION_AVOIDANCE:
logger.debug("MOTION: Collision Avoidance")
self.updateCollisionAvoidance()
if not collisionImminent:
self.setPrevStatus()
# During path find a object that can't be avoid
if obstacleDetected and not isUTurning and self.prevStatus == PATH_FOLLOWING:
logger.debug("Reset Path")
self.pathRunner.updatePath()
collisionImminent = False
self.collisionAvoidance.resetObstacleDetection()
self.setStatus(PATH_FOLLOWING)
elif self.status == STOP:
logger.debug("MOTION: Stop")
self.setSpeed(0)
self.setAngle(0)
self.parking.disable()
elif self.status == MANUAL:
logger.debug("MOTION: Manual")
self.manualDrive.enable()
self.updateManualDrive()
else:
logger.warning("MOTION STATUS: " + str(self.status))
self.setStatus(STOP)
def computeParkingAngleAndSpeed(self):
logger.debug("PARKING STATE: " + str(self.status))
# get distance sensors
ds = self.distanceSensors
# set reference
distanceTraveled = self.positioning.getActualDistance()
side = 0
front = 0
rear = 0
bside = 0
fside = 0
if self.status > SEARCH and self.sideOfParkingLot != UNKNOWN:
# get rear and side sensors values
rear = self.distanceSensors.backCenter.getValue()
front = self.distanceSensors.frontCenter.getValue()
if self.sideOfParkingLot == RIGHT:
side = self.distanceSensors.sideRight.getValue()
bside = self.distanceSensors.backRight.getValue()
fside = self.distanceSensors.frontRight.getValue()
elif self.sideOfParkingLot == LEFT:
side = self.distanceSensors.sideLeft.getValue()
bside = self.distanceSensors.backLeft.getValue()
fside = self.distanceSensors.frontLeft.getValue()
# SEARCH status 2
if self.status == SEARCH:
# set slow speed
self.speed = 0.2
# set straight wheels
self.angle = self.lineFollower.getNewSteeringAngle()
if self.lineFollower.isLineLost():
self.resetParkingPosition()
self.angle = self.lineFollower.getSteeringAngleLineSearching()
logger.debug("PARKING angle from Line Follower: " +
str(self.angle))
if abs(self.angle) > 0.25:
self.resetParkingPosition()
# side threshold, if side sensor is greather than threshold the parking lot if occupied
sideThreshold = 650
# get side left sensors values
leftSensorValue = ds.sideLeft.getValue()
rightSensorValue = ds.sideRight.getValue()
# checking parking lot on the LEFT side
if leftSensorValue < sideThreshold and not self.leftIsEmpty:
self.leftIsEmpty = True
self.leftStartingPosition = distanceTraveled
elif leftSensorValue > sideThreshold and self.leftIsEmpty:
self.leftIsEmpty = False
elif self.leftIsEmpty and distanceTraveled - self.leftStartingPosition > CAR_LENGTH + (
CAR_LENGTH * 2 / 3):
self.leftStartingPosition = distanceTraveled
self.sideOfParkingLot = LEFT
self.status = FORWARD
# checking parking lot on the RIGHT side
if rightSensorValue < sideThreshold and not self.rightIsEmpty:
self.rightIsEmpty = True
self.rightStartingPosition = distanceTraveled
elif rightSensorValue > sideThreshold and self.rightIsEmpty:
self.rightIsEmpty = False
elif self.rightIsEmpty and distanceTraveled - self.rightStartingPosition > CAR_LENGTH + (
CAR_LENGTH * 2 / 3):
self.rightStartingPosition = distanceTraveled
self.sideOfParkingLot = RIGHT
self.status = FORWARD
# FORWARD status 3
# this ensure that the parking manoeuvre starts after going forward and not as soon as the parking lot is detected
elif self.status == FORWARD:
# distance to travel before starting the maneuver
distance = 0.13
# check if distance traveled is greater than distance to travel
if self.sideOfParkingLot == LEFT:
if distanceTraveled - self.leftStartingPosition >= distance:
self.status = PARKING
elif self.sideOfParkingLot == RIGHT:
if distanceTraveled - self.rightStartingPosition >= distance:
self.status = PARKING
else:
# if parking is found but is not set the side
logger.warning(
"Parking lot found! But I don't know if right or left. Looking for anther one."
)
self.status = SEARCH
# starting the parking manoeuvre 4
elif self.status == PARKING:
# check is the side of the parking lot is known
if self.sideOfParkingLot != LEFT and self.sideOfParkingLot != RIGHT:
logger.error("Side of parking lot is unknown.")
# stop the vehicle, turn the wheels and go back slowly
self.angle = self.sideOfParkingLot
self.speed = -0.1
# back thresholds that tells when contursteer
backCenterThreshold = 610
backSideThreshold = 410
if self.sideOfParkingLot == LEFT:
backCenterThreshold = 625
backSideThreshold = 425
# debug log
logger.debug("Rear: " + str(rear) + " Back Park Side: " +
str(bside))
# if true countersteer
if bside > backSideThreshold or rear > backCenterThreshold:
self.status = PARKING2
# PARKING2 status 5
elif self.status == PARKING2:
# set countersteering angle
if self.angle != 0:
self.angle = -1 * self.sideOfParkingLot
self.speed = -0.05
# set side and back threshold
rearThreshold = 985
sideThreshold = 945
backSideThreshold = 915
# debug log
logger.debug("sideOfParkingLot: " + str(self.sideOfParkingLot) +
" side: " + str(side))
# check if the park is completed
if (bside <= fside and side >= 865):
self.status = CENTER
# check if need some orient adjust
if self.distanceSensors.backDistance(
sideThreshold): #and bside > fside:
self.status = ADJUST_POSITION
# ADJUST_POSITION status 6
elif self.status == ADJUST_POSITION:
# debug log
logger.debug("Need to adjust position")
# set angle
self.angle = self.sideOfParkingLot
self.speed = 0.05
# check if the park is completed
if (bside < fside and side > 865):
self.status = CENTER
if front > 925 or fside > 925 or not self.distanceSensors.backDistance(
825):
self.angle = -1 * self.sideOfParkingLot
self.status = PARKING2
# CENTER status 7
elif self.status == CENTER:
if rear > 950 or (rear < 100 and front < 700):
self.speed = 0.05
elif front > 950 or (front < 100 and rear < 700):
self.speed = -0.05
# set angle streight
if abs(bside - fside) < 50 and abs(rear - front) < 80:
self.angle = 0.0
self.status = STOP
logger.debug(
"TRYING TO STAY CENTER: same distance sides and rear and front!"
)
elif abs(bside - fside) < 50 and rear < 100 and front > 700:
self.angle = 0.0
self.status = STOP
logger.debug(
"TRYING TO STAY CENTER: there's nothing behind, stay ahead!"
)
elif abs(bside - fside) < 50 and rear < 100 and front > 700:
self.angle = 0.0
self.status = STOP
logger.debug(
"TRYING TO STAY CENTER: there's nothing behind, stay ahead!"
)
elif abs(bside - fside) < 50 and front < 100 and rear > 700:
self.angle = 0.0
self.status = STOP
logger.debug(
"TRYING TO STAY CENTER: there's nothing ahead, stay behind!"
)
elif abs(bside - fside) < 20:
self.angle = 0.0
logger.debug("TRYING TO STAY CENTER: same distance sides!")
else:
if self.speed > 0:
nextAngle = 0.2
else:
nextAngle = -0.2
if fside < bside:
nextAngle *= self.sideOfParkingLot
else:
nextAngle *= -self.sideOfParkingLot
self.angle = nextAngle
logger.debug("TRYING TO STAY CENTER: NEED TO GO " +
("right" if self.angle > 0 else "left"))
# STOP status 8
elif self.status == STOP:
self.speed = 0.0
self.angle = 0.0
# invalid status
else:
logger.debug("Invalid parcking status")
visionManager.updateRobotScales()
FPSCounter.update()
if visionManager.isObjectDetected: # if an object was detected
######################
# Rectangle creation #
######################
(x, y, h, w) = (
visionManager.currentImageObject.objectX,
visionManager.currentImageObject.objectY,
visionManager.currentImageObject.objectHeight,
visionManager.currentImageObject.objectWidth,
)
logger.debug("----------------")
logger.debug("Image Object (U):")
logger.debug("----------------")
logger.debug("Current U Width In Pixels: " + str(w))
logger.debug("Current U Height In Pixels: " + str(h))
logger.debug("Current U X In Pixels: " + str(x))
logger.debug("Current U Y In Pixels: " + str(y))
# (x, y) = top left corner, h+ is down, w+ is right
cv2.rectangle(visionManager.maskedImage, (x, y), (x + w, y + h), (0, 255, 0), 2)
#############################
# Send data to java process #
#############################
if visionManager.isObjectDetected and visionManager.robotObject is not None:
values = [
def setAngleAndSpeed(self, angle, speed):
logger.debug("Setting Actuators - Angle: " + str(angle) +
" - Speed: " + str(speed))
self.actuators.setAngle(angle * MAX_ANGLE)
self.actuators.setSpeed(speed * MAX_SPEED)
visionManager.updateImage()
visionManager.updateTowerScales()
visionManager.updateRobotScales()
FPSCounter.update()
if visionManager.isObjectDetected: # if an object was detected
######################
# Rectangle creation #
######################
(x, y, h, w) = (visionManager.currentImageObject.objectX,
visionManager.currentImageObject.objectY,
visionManager.currentImageObject.objectHeight,
visionManager.currentImageObject.objectWidth)
logger.debug("----------------")
logger.debug("Image Object (U):")
logger.debug("----------------")
logger.debug("Current U Width In Pixels: "+str(w))
logger.debug("Current U Height In Pixels: "+str(h))
logger.debug("Current U X In Pixels: "+str(x))
logger.debug("Current U Y In Pixels: "+str(y))
# (x, y) = top left corner, h+ is down, w+ is right
cv2.rectangle(visionManager.maskedImage, (x, y), (x + w, y + h), (0, 255, 0), 2)
#############################
# Send data to java process #
#############################
if visionManager.isObjectDetected and visionManager.robotObject is not None:
values = [visionManager.currentImageObject.distanceFromCamera,
def run(self):
logger.info("Running..")
leftIsEmpty = False # flag used to detect left parking lot
rightIsEmpty = False # flag used to detect right parking lot
leftStartingPosition = 0.0 # length of the left parking lot
rightStartingPosition = 0.0 # length of the right parking lot
sideOfParkingLot = 0 # indicates the side of the parking lot found: -1 left, 1 right, 0 not found yet
actualTurn = 0
while self.driver.step() != -1:
## here goes code that should be executed each step ##
# get actual compass value
#compassValues = self.compass.getValues()
#logger.debug("COMPASS: "******"INIT status")
# set wheel angle
self.setAngle(0.0)
# set starting speed
self.setSpeed(0.5)
# set new status
self.setStatus(Status.TURN)
# skip to next cycle to ensure everything is working fine
continue
# FOLLOW LINE STATUS
if self.status == Status.FOLLOW_LINE:
# set cruise speed
self.setSpeed(0.5)
# compute new angle
newAngle = self.lineFollower.getNewSteeringAngle()
# logger.debug("new steering angle: " + str(newAngle))
# set new steering angle
if newAngle != UNKNOWN:
self.setAngle(newAngle)
else:
self.setStatus(Status.TURN)
# TURN STATUS
if self.status == Status.TURN:
if actualTurn < len(self.turns):
turn = self.turns[actualTurn]
self.setAngle(0.5 * turn * MAX_ANGLE)
else:
self.setStatus(Status.STOP)
# compute new angle
newAngle = self.lineFollower.getNewSteeringAngle()
# if line is found
if newAngle != UNKNOWN:
self.setStatus(Status.FOLLOW_LINE)
actualTurn += 1
continue
# FORWARD STATUS
if self.status == Status.FORWARD:
# logger.debug("FORWARD status")
# set cruise speed
self.setSpeed(0.2)
# avoing obstacles
ds = self.distanceSensors
# get distance sensors values
frontLeftSensor = ds.frontLeft.getValue()
frontRightSensor = ds.frontRight.getValue()
sideLeftSensor = ds.sideLeft.getValue()
sideRightSensor = ds.sideRight.getValue()
# set values of thresholds
tolerance = 10
sideThreshold = 950
# check if front left obstacle, turn right
if frontLeftSensor > frontRightSensor + tolerance:
self.setAngle(RIGHT * frontLeftSensor / 500.0 * MAX_ANGLE)
# logger.debug("Steering angle: " + str(RIGHT * frontLeftSensor / 1000.0 * MAX_ANGLE))
logger.debug("Steering angle: " + str(self.angle))
# check if front right obstacle, turn left
elif frontRightSensor > frontLeftSensor + tolerance:
self.setAngle(LEFT * frontRightSensor / 500.0 * MAX_ANGLE)
# logger.debug("Steering angle: " + str(LEFT * frontRightSensor / 1000.0 * MAX_ANGLE))
logger.debug("Steering angle: " + str(self.angle))
# check if side left obstacle, turn slight right
elif sideLeftSensor > sideThreshold:
self.setAngle(RIGHT * sideLeftSensor / 4000.0 * MAX_ANGLE)
# check if side right obstacle, turn slight left
elif sideRightSensor > sideThreshold:
self.setAngle(LEFT * sideRightSensor / 4000.0 * MAX_ANGLE)
# if no obstacle go straight
else:
self.setAngle(self.angle / 1.5)
# SEARCHING_PARK STATUS
if self.status == Status.SEARCHING_PARK:
# set slow speed
self.setSpeed(0.2)
# set straight wheels
self.setAngle(0.0)
# get distance and position sensors
ds = self.distanceSensors
ps = self.positionSensors
#log info for debug
logger.debug("Left Distance Sensor: " +
str(ds.sideLeft.getValue()))
logger.debug("Left Position Sensor: " +
str(ps.frontLeft.getValue()) + " rad")
logger.debug("Left Wheel Length: " +
str(self.leftWheelDistance) + " m")
logger.debug("Starting position: " +
str(leftStartingPosition) + " m")
logger.debug("Parking Lot Length: " +
str(self.leftWheelDistance -
leftStartingPosition) + " m")
sideThreshold = 650
leftSensorValue = ds.sideLeft.getValue()
rightSensorValue = ds.sideRight.getValue()
# checking parking lot on the LEFT side
if leftSensorValue < sideThreshold and not leftIsEmpty:
leftIsEmpty = True
leftStartingPosition = self.leftWheelDistance # 100
elif leftSensorValue > sideThreshold and leftIsEmpty:
leftIsEmpty = False
elif leftIsEmpty and self.leftWheelDistance - leftStartingPosition > LENGTH + LENGTH / 3:
leftStartingPosition = self.leftWheelDistance # 200 - 100
sideOfParkingLot = LEFT
self.setStatus(Status.FORWARD2)
# checking parking lot on the RIGHT side
if rightSensorValue < sideThreshold and not rightIsEmpty:
rightIsEmpty = True
rightStartingPosition = self.rightWheelDistance
elif rightSensorValue > sideThreshold and rightIsEmpty:
rightIsEmpty = False
elif rightIsEmpty and self.rightWheelDistance - rightStartingPosition > LENGTH + LENGTH / 3:
rightStartingPosition = self.rightWheelDistance
sideOfParkingLot = RIGHT
self.setStatus(Status.FORWARD2)
# this ensure that the parking manoeuvre starts after going forward and not as soon as the parking lot is detected
if self.status == Status.FORWARD2:
distance = 0.19
if sideOfParkingLot == LEFT:
if self.leftWheelDistance - leftStartingPosition > distance:
self.status = Status.PARKING
elif sideOfParkingLot == RIGHT:
if self.rightWheelDistance - rightStartingPosition > distance:
self.status = Status.PARKING
else:
logger.warning(
"Parking lot not found! I don't know if right or left."
)
self.setStatus(Status.SEARCHING_PARK)
# starting the parking manoeuvre
if self.status == Status.PARKING:
if sideOfParkingLot != LEFT and sideOfParkingLot != RIGHT:
logger.error("side of parking lot unknown.")
exit(1)
# stop the vehicle, turn the wheels and go back
self.setSpeed(0.0)
self.setAngle(sideOfParkingLot * MAX_ANGLE)
self.setSpeed(-0.1)
# when should it turn the other way
backThreshold = 400
ds = self.distanceSensors
rear = ds.back.getValue()
logger.debug("Back sensor: " + str(rear))
if rear > backThreshold:
self.status = Status.PARKING2
if self.status == Status.PARKING2:
self.setAngle(-1 * sideOfParkingLot * MAX_ANGLE)
threshold = 945
rear = self.distanceSensors.back.getValue()
if rear > threshold:
self.setStatus(Status.CENTER)
if self.status == Status.CENTER:
self.setAngle(0.0)
self.setSpeed(0.2)
rear = self.distanceSensors.back.getValue()
front = self.distanceSensors.frontCenter.getValue()
if rear - front < 20:
self.setStatus(Status.STOP)
if self.status == Status.STOP:
self.setSpeed(0.0)
self.setAngle(0.0)
# if obstacle is cleared go forward
if not self.avoidObstacle(
) and self.prevStatus == Status.PARKING2:
self.setStatus(Status.FORWARD)
if self.status == Status.MANUAL:
# get current state
speed = self.speed
angle = self.angle
# logger.debug("Current Key: " + str(currentKey))
# keyboard controlls
# accelerate
if currentKey == self.keyboard.UP:
if speed < 0:
speed += 0.02
else:
speed += 0.008
# break
elif currentKey == self.keyboard.DOWN:
if speed > 0:
speed -= 0.02
else:
speed -= 0.008
# turn left
elif currentKey == self.keyboard.LEFT:
angle -= 0.01
# turn right
elif currentKey == self.keyboard.RIGHT:
angle += 0.01
# handbreak
elif currentKey == ord(' '):
speed /= 4
# update state
self.setSpeed(speed)
self.setAngle(angle)
