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)
