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)