def create_zero_condition(side): assert isinstance(side, Side) and len(side) > 0 var = side.get_the_latest_variable() if len(side) == 0: return Condition(Side(var), side, StateConditions.IS_ZERO) else: return Condition(Side(var), side, StateConditions.IS_EQUAL)
def generate_conditions(self): if len(self.__conditions) > 0: return self.__conditions max_bits = len(self.__input_variables) max_number = pow(2, max_bits) all_zero_pos = [] for x in xrange(1, max_number - 1): all_zero_pos.append(self.get_num_bits(x, max_bits)) all_zero_pos.sort(self.comparator) all_zero_pos.append([]) for zero_pos in all_zero_pos: zero_vars = [] none_zero_vars = [] for ind in xrange(len(self.__input_variables)): if ind in zero_pos: zero_vars.append(Condition( Side(self.__input_variables[ind]), Side(), StateConditions.IS_ZERO) ) else: none_zero_vars.append(Condition( Side(self.__input_variables[ind]), Side(), StateConditions.IS_NOT_ZERO)) self.__conditions.append(CommonCondition(zero_vars, none_zero_vars)) return "OK"
def breaks_advantage(insetscore, srv_side: Side): """breaks advantage for left: 0 - no adv. n>0 left leads n breaks. n<0 left trails. >>> breaks_advantage((1, 1), srv_side=co.LEFT) 0 >>> breaks_advantage((0, 1), srv_side=co.LEFT) 0 >>> breaks_advantage((2, 0), srv_side=co.LEFT) 1 >>> breaks_advantage((1, 2), srv_side=co.RIGHT) -1 >>> breaks_advantage((3, 0), srv_side=co.LEFT) 2 >>> breaks_advantage((1, 4), srv_side=co.RIGHT) -2 >>> breaks_advantage((0, 6), srv_side=co.LEFT) -3 """ diff = insetscore[0] - insetscore[1] if diff == 0: return 0 if diff < 0: return -breaks_advantage(co.reversed_tuple(insetscore), srv_side.fliped()) # only left may have advantage if srv_side.is_left(): return (diff + 1) // 2 else: return diff // 2
def __init__(self, n, T): side = 3 self.noOfVert = self.getRandomInt(n) print("No of Vertices is: ", self.noOfVert) for i in range(self.noOfVert): if T is 1: self.generateRandomPoint() else: self.generateRandomPointRational() vertLen = len(self.verts) if i > 0: for j in range(1): self._sideX.append(self.verts[vertLen - (2 - j)].getX()) self._sideY.append(self.verts[vertLen - (2 - j)].getY()) __s = Side(self._sideX[0], self._sideY[0], self._sideX[1], self._sideY[1]) self.sides.append(__s) self._sideX.pop() self._sideY.pop() if len(self.sides) == len(self.verts) - 1: l = len(self.verts) - 1 __S = Side(self.verts[1].getX, self.verts[1].getY(), self.verts[0].getX, self.verts[0].getY()) self.sides.append(__S)
def opener_s2choke_adv(): s2loser = Side(match.score[1][0] < match.score[1][1]) if s2loser.is_left(): was_breakup = match.quad_stat.breakup_tracker.is_fst_breakup( setnum=2) else: was_breakup = match.quad_stat.breakup_tracker.is_snd_breakup( setnum=2) if not was_breakup: return 0 return -1 if decset_open_side == s2loser else 1
def __init__(self, message_repository): self._logger = logging.getLogger(self.__class__.__name__) assert isinstance(message_repository, MessageRepository), type(message_repository) self.message_repository = message_repository self._trades = deque(maxlen=100) # List of trades with a limit of 100 self._bids = Side() self._asks = Side() self._last_message = None # The last message processed by this order book self._last_timestamp = Timestamp(0.0) # The time at which the last message was processed
def test_set_win_prob_53(self): prob = Prob(win_point=0.63, hold=0.65) res_pr = set_win_prob( prob=prob, set_scr=(5, 3), game_scr=(3, 0), game_opener=Side("LEFT"), target_side=Side("LEFT"), ) self.assertTrue(res_pr is not None) self.assertTrue(0.7 < res_pr < 1)
def test_set_win_prob_00(self): prob = Prob(win_point=0.63, hold=0.65) res_pr = set_win_prob( prob=prob, set_scr=(0, 0), game_opener=Side("LEFT"), game_scr=(0, 0), target_side=Side("LEFT"), ) self.assertTrue(res_pr is not None) print(f"res_pr_00: {res_pr}") self.assertTrue(0.51 < res_pr < 1)
def __generate_condition_func(zero_conds: List[Condition], var: Variable, var_with_lo: Variable, var_output: Variable): var_is_zero = False var_with_lo_is_zero = False for zcond in zero_conds: if zcond.check_contains_var(var, ConditionState.IS_ZERO): var_is_zero = True elif zcond.check_contains_var(var_with_lo, ConditionState.IS_ZERO): var_with_lo_is_zero = True if var_is_zero and var_with_lo_is_zero: return [Condition.create_zero_condition(Side(var_output.clone()))] elif (var_is_zero and not var_with_lo_is_zero) or (not var_is_zero and var_with_lo_is_zero): return [Condition.create_non_zero_condition(Side(var_output.clone()))] else: # (not var_is_zero and not var_with_lo_is_zero) return [Condition.create_zero_condition(Side(var_output.clone())), Condition.create_non_zero_condition(Side(var_output.clone()))]
def _is_side_non_zero(self, side: Side) -> bool: if len(side) == 1 and side.get_first().is_zero(): return True for nzcondition in self._conds_non_zero: assert nzcondition.get_state() == ConditionState.IS_NOT_ZERO if nzcondition.get_left_side() == side: return True return False
def test_to_srt(): global a1, a2, a3 assert "{} = {}".format(a1, a2) == str( Condition(Side(a1), Side(a2), ConditionState.IS_EQUAL)) assert "{} != 0".format(a1) == str( Condition(Side(a1), Side(), ConditionState.IS_NOT_ZERO)) assert "{} != {}".format(a1, a2) == str( Condition(Side(a1), Side(a2), ConditionState.IS_NOT_ZERO)) assert "{} = 0".format(a1) == str( Condition(Side(a1), Side(), ConditionState.IS_ZERO))
def side_prefer(self, side: Side, dif: Union[float, int]) -> Optional[bool]: if self.left_prefer is None: return None # ни у кого нет преимущества if side.is_left() != self.left_prefer: return False if self.dif is None: return True return self.dif >= dif
def get_adv_side(fst_sv: SizedValue, snd_sv: SizedValue) -> Optional[Side]: """ return Side('LEFT') if fst_sv has advantage, Side('RIGHT') if snd_sv has advantage, None if nobody has advantage """ if fst_sv is None or snd_sv is None: return None fst_val, snd_val = fst_sv.value, snd_sv.value if fst_val is None or snd_val is None: return None if min_adv_size == min_oppo_size: fst_val, snd_val = co.twoside_values(fst_sv, snd_sv) if (fst_sv.size >= min_adv_size and snd_sv.size >= min_oppo_size and fst_val >= min_adv_value and snd_val <= max_oppo_value): return Side('LEFT') if (fst_sv.size >= min_oppo_size and snd_sv.size >= min_adv_size and fst_val <= max_oppo_value and snd_val >= min_adv_value): return Side('RIGHT')
def lagSider(antall): sider = {} farger = ["blå", "rød", "grønn", "gul", "oransje", "hvit"] for i in range(antall): farge = farger[random.randint(0, 5)] lengde = random.randint(1, 5) side = Side(lengde, farge) sider[i] = side return sider
def __init__(self, left_side: Side, right_side: Side, state: ConditionState) -> None: """ left_side - is list of Variables left_side - is list of Variables or None if state equal IS_ZERO state - state of condition """ if not right_side.is_empty() and state == ConditionState.IS_ZERO: assert "Internal error" == 0 self.__state = state # type: ConditionState self.__left_side = left_side # type: Side self.__right_side = right_side # type: Side
def __init__(self, arg): super(GameLog, self).__init__() self.arg = arg self._logAttributes = LogAttribute() self._logEmpty self._logType = LogType() self._game = Game() self._side = Side() self._teamPlayer = TeamPlayer() self._logDate self._logMinutes
def __init__(self, rail_cars=0): self.config = lib.get_config() self.PID_values = self.config["IR_PID"] self.device = IR() # INSTANTIATE ONLY ONCE self.north = Side("North Left", "North Right", self.device.read_values, self.PID_values["North"]["diff"], self.PID_values["North"]["dist"]) self.south = Side("South Left", "South Right", self.device.read_values, self.PID_values["South"]["diff"], self.PID_values["South"]["dist"]) self.east = Side("East Top", "East Bottom", self.device.read_values, self.PID_values["East"]["diff"], self.PID_values["East"]["dist"]) self.west = Side("West Top", "West Bottom", self.device.read_values, self.PID_values["West"]["diff"], self.PID_values["West"]["dist"]) self.driver = OmniDriver() self.sides = {"north": self.north, "south": self.south, "west": self.west, "east": self.east} self.moving = False self.logger = lib.get_logger() mapping = ["EXIT", "west", "east", "EXIT"] self.rail_cars_side = mapping[rail_cars]
def __init__(self, dispatcher): self.dispatcher = dispatcher self.masks = {c: Mask(c, dispatcher) for c in COLORS} self.entities = [] self.sides = [Side(name) for name in ['top', 'left', 'right']] self.image = None self.current_frame = None self.tracked_entities = {} self.width = None self.height = None self.collisions = None self.balls = None
def test_set_win_prob_54(self): prob = Prob(win_point=0.63, hold=0.65) res_pr = set_win_prob( prob=prob, set_scr=(4, 5), game_opener=Side("RIGHT"), game_scr=(3, 0), target_side=Side("RIGHT"), ) self.assertTrue(res_pr is not None) self.assertTrue(0.7 < res_pr < 1, f"{res_pr} <= 0.7") res_pr2 = set_win_prob( prob=prob, set_scr=(4, 5), game_opener=Side("RIGHT"), game_scr=(0, 3), target_side=Side("RIGHT"), ) self.assertTrue(res_pr2 is not None) self.assertTrue(0.45 < res_pr2 < 0.6)
def __init__(self, rail_cars=0): self.config = lib.get_config() self.PID_values = self.config["IR_PID"] self.device = IR() # INSTANTIATE ONLY ONCE self.north = Side("North Left", "North Right", self.device.read_values, self.PID_values["North"]["diff"], self.PID_values["North"]["dist"]) self.south = Side("South Left", "South Right", self.device.read_values, self.PID_values["South"]["diff"], self.PID_values["South"]["dist"]) self.east = Side("East Top", "East Bottom", self.device.read_values, self.PID_values["East"]["diff"], self.PID_values["East"]["dist"]) self.west = Side("West Top", "West Bottom", self.device.read_values, self.PID_values["West"]["diff"], self.PID_values["West"]["dist"]) self.driver = OmniDriver() self.sides = { "north": self.north, "south": self.south, "west": self.west, "east": self.east } self.moving = False self.logger = lib.get_logger() mapping = ["EXIT", "west", "east", "EXIT"] self.rail_cars_side = mapping[rail_cars]
def tie_opener_side(num_ingame, srv_side: Side): """По текущему num_ingame (2-tuple) и текущему подающему вернем открывателя >>> tie_opener_side((0, 0), srv_side=co.LEFT) Side('LEFT') >>> tie_opener_side((0, 0), srv_side=co.RIGHT) Side('RIGHT') >>> tie_opener_side((1, 0), srv_side=co.LEFT) Side('RIGHT') >>> tie_opener_side((1, 1), srv_side=co.LEFT) Side('RIGHT') >>> tie_opener_side((1, 1), srv_side=co.RIGHT) Side('LEFT') """ return srv_side if tie_opener_serve_at(num_ingame) else srv_side.fliped()
def get_curset_opener_by_next(cursetnum, nextset_opener: Side, all_score): """ here all_score can be also Score object >>> get_curset_opener_by_next(1, nextset_opener=co.LEFT, all_score=((6, 2), (6, 3))) Side('LEFT') >>> get_curset_opener_by_next(1, nextset_opener=co.LEFT, all_score=((6, 1), (6, 3))) Side('RIGHT') """ curscr = all_score[cursetnum - 1] curset_lastg_opener = nextset_opener.fliped() curset_opener = ( curset_lastg_opener if sum(curscr) % 2 == 1 else curset_lastg_opener.fliped() ) return curset_opener
def gen_all_common_conditions( self, variables: List[Variable] ) -> List[Tuple[List[Condition], List[Condition]]]: assert all([ isinstance(x, Variable) and not x.is_unknown() for x in variables ]) cconditions = [] # type: List[Tuple[List[Condition], List[Condition]]] assert len(variables) > 0 for zero_pos in self.__generate_zero_positions(variables): zero_conds = [] # type: List[Condition] none_zero_conds = [] # type: List[Condition] for index in range(len(variables)): if index in zero_pos: zero_conds.append( Condition(Side(variables[index]), Side(), ConditionState.IS_ZERO)) else: none_zero_conds.append( Condition(Side(variables[index]), Side(), ConditionState.IS_NOT_ZERO)) cconditions.append((zero_conds, none_zero_conds)) return cconditions
def get_curset_opener(cursetnum, prevset_opener: Side, all_score): """ here all_score can be also Score object >>> get_curset_opener(cursetnum=2, prevset_opener=co.LEFT, all_score=((6, 2), (6, 3))) Side('LEFT') >>> get_curset_opener(cursetnum=2, prevset_opener=co.LEFT, all_score=((6, 1), (6, 3))) Side('RIGHT') """ assert 1 <= cursetnum <= 5 assert prevset_opener in (co.LEFT, co.RIGHT) prevscr = all_score[cursetnum - 2] prevset_lastg_opener = ( prevset_opener if sum(prevscr) % 2 == 1 else prevset_opener.fliped() ) return prevset_lastg_opener.fliped()
def write_bf_live_coef(date: datetime.date, sex: str, fst_id: int, snd_id: int, case_name: str, back_side: Side, bf_live_coef: float): if predicts_db_hnd is None: return if back_side.is_left(): back_id, oppo_id = fst_id, snd_id else: back_id, oppo_id = snd_id, fst_id rec = predicts_dbsa.find_predict_rec_by(predicts_db_hnd.session, sex, date, case_name, back_id=back_id, oppo_id=oppo_id) if isinstance(rec, predicts_dbsa.PredictRec): rec.bf_live_coef = bf_live_coef _commit(bytime=False)
def write_rejected(match, case_name: str, back_side: Side, reason: str = ""): if predicts_db_hnd is None: return if back_side.is_left(): back_id, oppo_id = match.first_player.ident, match.second_player.ident else: back_id, oppo_id = match.second_player.ident, match.first_player.ident rec = predicts_dbsa.find_predict_rec_by(predicts_db_hnd.session, match.sex, match.date, case_name, back_id=back_id, oppo_id=oppo_id) if isinstance(rec, predicts_dbsa.PredictRec): rec.rejected = 1 if reason: rec.comments = cut_comments(rec.comments + " " + reason) _commit(bytime=False)
def create_zero_condition(side: Side) -> 'Condition': assert isinstance(side, Side) and not side.is_empty() s = str(side) var = side.pop_the_latest_variable() s_var = str(var) assert var is not None try: side.move_lo_from_var(var) except SideException as se: raise ConditionException("Can not create zero condition {}".format(s)) c = Condition(Side(var), side, ConditionState.IS_ZERO if side.is_empty() else ConditionState.IS_EQUAL) logger.info("create_zero_condition: var: {}; side: {}. => '{}'".format(s_var, s, c)) return c
def match_has_min_proba(match, decset_open_side: Side): def log_estimate(): if positive_prob > negative_prob: max_prob = round(positive_prob, 3) max_prob_plr = (match.second_player if decset_open_side.is_left() else match.first_player) back_beg_txt = "CLOSER" else: max_prob = round(negative_prob, 3) max_prob_plr = (match.first_player if decset_open_side.is_left() else match.second_player) back_beg_txt = "OPENER" log.info(f"clf {MODEL} try {match} \nopen_side:{decset_open_side} " f"PROB: {max_prob} {back_beg_txt} PLR {max_prob_plr}") predicts_db.write_predict( match, case_name='decided_00', back_side=co.LEFT if max_prob_plr is match.first_player else co.RIGHT, proba=max_prob, comments=back_beg_txt) try: variant = cco.Variant.find_match_variant(match, apply_variants) if variant is None: log.error("clf {} novarianted for: {}".format( MODEL, match.tostring())) return None, None X_test = decset_match_features(match, decset_open_side, variant) clf = variant.clf proba = clf.predict_proba(X_test) positive_prob = float(proba[0, 1]) negative_prob = float(proba[0, 0]) log_estimate() if positive_prob >= variant.min_probas.pos: return decset_open_side.fliped(), positive_prob elif negative_prob >= variant.min_probas.neg: return decset_open_side, negative_prob except cco.FeatureError as err: log.warn("clf {} prep err: {} {}".format(MODEL, err, match.tostring())) return None, None return None, None
def tie_serve_side_at(num_ingame, tie_open_side: Side) -> Side: """По текущему num_ingame (2-tuple) и открывателю вернем текущего подающего >>> tie_serve_side_at((0, 0), tie_open_side=co.LEFT) Side('LEFT') >>> tie_serve_side_at((0, 1), tie_open_side=co.LEFT) Side('RIGHT') >>> tie_serve_side_at((1, 1), tie_open_side=co.LEFT) Side('RIGHT') >>> tie_serve_side_at((1, 1), tie_open_side=co.RIGHT) Side('LEFT') >>> tie_serve_side_at((1, 5), tie_open_side=co.LEFT) Side('RIGHT') >>> tie_serve_side_at((1, 6), tie_open_side=co.LEFT) Side('LEFT') """ if tie_opener_serve_at(num_ingame): return tie_open_side else: return tie_open_side.fliped()
def get_tie_open_side(num_ingame, serve_side: Side) -> Side: """По текущему num_ingame (2-tuple) и подающему вернем открывателя тайбрейка >>> get_tie_open_side((0, 0), serve_side=co.LEFT) Side('LEFT') >>> get_tie_open_side((0, 1), serve_side=co.LEFT) Side('RIGHT') >>> get_tie_open_side((1, 1), serve_side=co.LEFT) Side('RIGHT') >>> get_tie_open_side((1, 1), serve_side=co.RIGHT) Side('LEFT') >>> get_tie_open_side((1, 5), serve_side=co.LEFT) Side('RIGHT') >>> get_tie_open_side((1, 5), serve_side=co.RIGHT) Side('LEFT') """ summa = (num_ingame[0] + num_ingame[1]) % 4 if summa in (0, 3): return serve_side else: return serve_side.fliped()
def srv_side_at_begin(self, setnum: int): if ( self.setnum is not None and self.inset is not None and self.is_left_srv is not None ): if self.setnum == setnum: return ( Side(self.is_left_srv) if co.is_even(sum(self.inset)) else Side(not self.is_left_srv) ) if (self.setnum + 1) == setnum and max(self.inset) >= 5: prob_set_winner = Side(self.inset[0] > self.inset[1]) if self.is_left_srv is prob_set_winner.is_left(): return prob_set_winner.fliped() return prob_set_winner
def makeSideCuts(): p0 = Base.Vector(115,-4,10) lp = Base.Vector(100,0,0) util.makeRef(p0, p0+a3ht, p0+a3ht+a3lt+lp, Base.Vector(0,30)) side = Side() Part.show(side.makeSides()[0])
class Navigation(object): def __init__(self, rail_cars=0): self.config = lib.get_config() self.PID_values = self.config["IR_PID"] self.device = IR() # INSTANTIATE ONLY ONCE self.north = Side("North Left", "North Right", self.device.read_values, self.PID_values["North"]["diff"], self.PID_values["North"]["dist"]) self.south = Side("South Left", "South Right", self.device.read_values, self.PID_values["South"]["diff"], self.PID_values["South"]["dist"]) self.east = Side("East Top", "East Bottom", self.device.read_values, self.PID_values["East"]["diff"], self.PID_values["East"]["dist"]) self.west = Side("West Top", "West Bottom", self.device.read_values, self.PID_values["West"]["diff"], self.PID_values["West"]["dist"]) self.driver = OmniDriver() self.sides = {"north": self.north, "south": self.south, "west": self.west, "east": self.east} self.moving = False self.logger = lib.get_logger() mapping = ["EXIT", "west", "east", "EXIT"] self.rail_cars_side = mapping[rail_cars] def stop_unused_motors(self, direction): direction = direction.lower() if direction == "north" or direction == "south": self.driver.set_motor("north", 0) self.driver.set_motor("south", 0) elif direction == "east" or direction == "west": self.driver.set_motor("east", 0) self.driver.set_motor("west", 0) @lib.api_call def move_correct(self, direction, side, target, speed, timestep, threshold=1000000): # speed >= 0 side = side.lower() diff_err = self.sides[side].get_diff_correction( timestep, threshold) # setting speed bounds sne = bound(speed-diff_err, -100, 100) # sne = -100 if sne < -100 else 100 if sne > 100 else sne spe = bound(speed+diff_err, -100, 100) #spe = -100 if spe < -100 else 100 if spe > 100 else spe #self.logger.info("Error from PID : %d", diff_err) dist_err = self.sides[side].get_dist_correction(target, timestep) #self.logger.info("dist Error from PID : %d", dist_err) dist_err = bound(dist_err, -100, 100) if side == "north": self.driver.set_motor("east", -dist_err) self.driver.set_motor("west", -dist_err) if direction == "west": self.driver.set_motor("north", -spe) self.driver.set_motor("south", -sne) if direction == "east": self.driver.set_motor("north", sne) self.driver.set_motor("south", spe) elif side == "south": self.driver.set_motor("east", dist_err) self.driver.set_motor("west", dist_err) if direction == "west": self.driver.set_motor("north", sne) self.driver.set_motor("south", spe) if direction == "east": self.driver.set_motor("north", sne) self.driver.set_motor("south", -spe) elif side == "east": self.driver.set_motor("north", -dist_err) self.driver.set_motor("south", -dist_err) if direction == "north": self.driver.set_motor("west", sne) self.driver.set_motor("east", spe) elif direction == "south": self.driver.set_motor("west", -spe) self.driver.set_motor("east", -sne) elif side == "west": self.driver.set_motor("north", dist_err) self.driver.set_motor("south", dist_err) if direction == "north": self.driver.set_motor("west", spe) self.driver.set_motor("east", sne) elif direction == "south": self.driver.set_motor("west", -sne) self.driver.set_motor("east", -spe) else: raise Exception() def move_dead(self, direction, speed): direction = direction.lower() dirs = {"north": 0, "west": 90, "south": 180, "east": 270} self.driver.move(speed, dirs[direction]) def drive_dead(self, direction, speed, duration): self.move_dead(direction, speed) sleep(duration) self.stop() @lib.api_call def drive_along_wall(self, direction, side, duration): time_elapsed = time() final_time = time_elapsed + duration while time_elapsed < final_time: timestep = time()-time_elapsed time_elapsed = time() if direction == "west" or direction == "east": self.move_correct(direction, side, 300, 65, timestep) else: self.move_correct(direction, side, 300, 50, timestep) sleep(0.01) self.stop() @lib.api_call def test(self): #self.drive_along_wall("west", "north", 5) self.move_until_wall("north", "east", 400) @lib.api_call def move_until_wall(self, direction, side, target, dist=150): direction = direction.lower() mov_side = self.sides[direction] mov_target = dist self.moving = True time_elapsed = time() while self.moving: timestep = time() - time_elapsed time_elapsed = time() self.move_correct(direction, side, mov_target, 60, timestep) if mov_side.get_distance() <= target: self.stop() #TODO: Update the controller in this function @lib.api_call def move_smooth_until_wall(self, direction, side, target, dist=150, t_type="avg"): direction = direction.lower() mov_side = self.sides[direction] mov_target = dist self.moving = True time_elapsed = time() speed = 0 speed_pid = PID() speed_pid.set_k_values(4, 0.01, 0) while self.moving: timestep = time() - time_elapsed time_elapsed = time() speed = speed_pid.pid(0, target - mov_side.get_distance(), timestep) if direction == "east" or direction == "west": speed = bound(speed, -65, 65) else: speed = bound(speed, -65, 65) self.move_correct(direction, side, mov_target, speed, timestep) if mov_side.get_distance(t_type) <= target: self.stop() def move_to_position(self, x, y): self.move_until_wall(self, "west", "north", x) sleep(0.5) self.move_until_wall(self, "north", "west", y) sleep(0.5) @lib.api_call def stop(self): self.driver.move(0) self.moving = False @lib.api_call def set_PID_values(self, side_to_set, pid, kp, kd, ki): set_side = self.sides[side_to_set] if (pid == "diff"): set_side.diff_pid.set_k_values(kp, kd, ki) elif(pid == "dist"): set_side.dist_pid.set_k_values(kp, kd, ki) # write updated PID values to the IR_config file # with open("IR_config.yaml") as f: # a = yaml.load(f) # a["IR_PID"][side_to_set][pid] = [kp, kd, ki] # with open("IR_config.yaml", "w") as f: # yaml.dump(a, f) @lib.api_call def read_IR_values(self): self.logger.info("Test") return self.device.read_values() @lib.api_call def move_until_color(self, direction, side, color): direction = direction.lower() mov_side = self.sides[direction] self.logger.info self.moving = True time_elapsed = time() while self.moving: timestep = time() - time_elapsed time_elapsed = time() self.move_correct(direction, side, 180, 55, timestep) ir_values = mov_side.get_values() # IR sensor for line detection is attached to South Left ir_value = ir_values["South Left"] if color == "white": if ir_value >= 1000: self.stop() else: if ir_value <= 1000: self.stop() @lib.api_call def rotate_start(self): ir_values = self.device.read_values() # If North side is facing inner wall of tunnel rotate until East top can see inner wall. while ir_values["East Bottom"] > 200 and ir_values["East Top"] > 200: # counter clockwise self.driver.rotate_t(60, .1) sleep(.1) ir_values = self.device.read_values() self.logger.info("Now straightening out") # Straighten out inside the tunnel ir_values = self.device.read_values() ir_diff = abs(ir_values["East Bottom"] - ir_values["East Top"]) while (ir_diff > 20): if ir_values["East Bottom"] < ir_values["East Top"]: # clockwise self.driver.rotate_t(-60, .1) sleep(0.1) elif ir_values["East Bottom"] > ir_values["East Top"]: # counter clockwise self.driver.rotate_t(60, .1) sleep(0.1) else: break ir_values = self.device.read_values() ir_diff = abs(ir_values["East Bottom"] - ir_values["East Top"]) @lib.api_call def goto_top(self): if self.east.get_distance() < MAX_VALUE: self.move_smooth_until_wall("north", "east", 300) elif self.west.get_distance() < MAX_VALUE: self.move_smooth_until_wall("north", "west", 300) @lib.api_call def goto_railcar(self): self.goto_top() self.logger.info("Currently near barge") if self.rail_cars_side == "west": self.logger.info("Going west towards railcars") self.move_smooth_until_wall("west", "north", 150, t_type="min") elif self.rail_cars_side == "east": self.logger.info("Going east towards railcars") self.move_smooth_until_wall("east", "north", 150, t_type="min") # TODO: Make a gotoBoat function # go north towards block, then towards rail cars and straight down def goto_boat(self): self.goto_railcar() if self.rail_cars_side == "west": self.move_until_wall("south", "west", 200) elif self.rail_cars_side == "east": self.move_until_wall("south", "east", 200) def goto_truck(self): self.goto_top() if self.rail_cars_side == "west": self.move_until_wall("east", "north", 150) if self.rail_cars_side == "east": self.move_until_wall("west", "north", 150) self.move_until_wall("south", "south", 150) def goto_block_zone_A(self): self.goto_railcar() @lib.api_call def goto_block_zone_B(self): self.goto_top() self.logger.info("sensor value: %d",self.east.get_distance()) self.logger.info("sensor value: %d", self.west.get_distance()) if self.east.get_distance() < MAX_VALUE: self.logger.info("I'm on right side of course. Going to white line on my left") self.move_until_color("west", "north", "white") elif self.west.get_distance() < MAX_VALUE: self.logger.info("I'm on left side of course. Going to white line on my right") self.move_until_color("east", "north", "white") self.logger.info("Reached Zone B") @lib.api_call def bang(self, side="north"): self.drive_dead(side, 50, 0.5) @lib.api_call def get_off_wall(self): self.drive_dead("south", 50, 0.333) @lib.api_call def correct_bang(self): self.get_off_wall() self.drive_dead("north", 50, 0.7) self.logger.info("Aligned with barge") @lib.api_call def bang_railcar(self): self.drive_dead(self.rail_cars_side, 60, 0.5) @lib.api_call def get_off_railcar(self): if self.rail_cars_side == "east": self.drive_dead("west", 60, 0.5) else: self.drive_dead("east", 60, 0.5) @lib.api_call def correct_bang_railcar(self): self.get_off_railcar() self.drive_dead(self.rail_cars_side, 60, 0.7) self.logger.info("Aligned with railcars") def goto_block_zone_C(self): self.goto_top() if self.rail_cars_side == "west": self.move_until_wall("east", "north", 100) if self.rail_cars_side == "east": self.move_until_wall("west", "north", 100) @lib.api_call def set_bias(self, side, bias): side = side.replace("_", " ") self.device.set_bias(side,bias) @lib.api_call def get_sensor_value(self, value): if "_" in value: value = value.replace("_", " ") try: return self.read_IR_values()[value] except KeyError: self.logger.warning("Invalid Key for IR Values %s"%value) #TODO: to be tested @lib.api_call def goto_next_railcar(self): def avg(vals): return sum(vals)/float(len(vals)) self.moving = True speed = 50 sensor = "West Bottom" last_value = self.get_sensor_value(sensor) self.logger.info("sensor value: %d", last_value) last_set = [last_value for i in xrange(10)] time_elapsed = time() self.move_dead("south", speed) while self.moving: timestep = time() - time_elapsed time_elapsed = time() curr_value = self.get_sensor_value(sensor) self.logger.info("sensor Type: %s, sensor value: %d, avg: %d", sensor, curr_value, avg(last_set)) diff = curr_value - avg(last_set) self.move_correct("south", self.rail_cars_side, 150, speed, timestep, threshold=100) if diff > 50: break if sensor == "West Bottom": sensor = "West Top" speed = 35 last_set = [curr_value for i in xrange(10)] else: self.moving = False break last_set.pop(0) last_set.append(curr_value) sleep(0.01) self.stop() @lib.api_call def drive_through_tunnel(self): self.move_through_tunnel(-75 ,-75 ,75 ,90 ,.85) sleep(.8) self.logger.info("Climbed the tunnel") self.rotate_start() self.logger.info("Auto-corrected inside tunnel") sleep(0.8) if self.rail_cars_side == "west": self.move_smooth_until_wall("north", "east", 500) else: self.move_smooth_until_wall("north", "west", 500) self.logger.info("Reached the barge") sleep(0.8) @lib.api_call def move_s(self, north=-100, south=-100, west=80, east=80): self.driver.set_motor("east", east) self.driver.set_motor("north", north) self.driver.set_motor("south", south) self.driver.set_motor("west", west) @lib.api_call def move_through_tunnel(self, north=-100, south=-100, west=80, east=80, duration=.75): self.move_s(north,south,west,east) sleep(duration) self.stop()
b.translate(Base.Vector(600)) for p in parts: if reverse: p.rotate(Base.Vector(0), Base.Vector(0,0,1),180) p.rotate(Base.Vector(0), Base.Vector(0,0,1),90) p.translate(Base.Vector(0,1100)) return parts util.makeRef(Base.Vector(0,0) ,Base.Vector(1220,0) ,Base.Vector(1220,2440) ,Base.Vector(0,0,18)) s1 = Side().makeSide() s2 = Side().makeSide() s3 = Side().makeSide() s4 = Side().makeSide() s5 = Side().makeSide() s6 = Side().makeSide() sides = [s1,s2,s3,s4,s5,s6] for s in sides: s.rotate(Base.Vector(18), Base.Vector(1),-90) s2.rotate(Base.Vector(0), Base.Vector(0,0,1),180) s2.translate(Base.Vector(730,300+470)) s3.translate(Base.Vector(0,800)) s4.rotate(Base.Vector(0), Base.Vector(0,0,1),180)