def __init__(self):
self.right_arm = Arm()
self.left_arm = Arm()
self.front_right_wheel = Wheel()
self.back_right_wheel = Wheel()
self.front_left_wheel = Wheel()
self.back_left_wheel = Wheel()
def __init__(self, wheel_point1, wheel_radius1, wheel_point2,
wheel_radius2, height):
self.wheel1 = Wheel(wheel_point1, wheel_radius1 * 0.6, wheel_radius1)
self.wheel2 = Wheel(wheel_point2, wheel_radius2 * 0.6, wheel_radius2)
# TODO - Get the point coordinates to get the corners
self.body = Rectangle(
Point(wheel_point1.getX(),
wheel_point1.getY() - height),
Point(wheel_point2.getX(), wheel_point2.getY()))
def __init__(self,u_color):
self.front_wheel = Wheel(16)
self.rear_wheel = Wheel(16)
self.pedal = True
self.handlebars = True
self.frame = True
self.brakes = True
self.color = u_color
self.speed = 0
def __init__(self):
self.reducer = 100 * 52.0 / 11
self.len_chain = 3.7775
self.left_wheel = Wheel(1, '/dev/ttyS2', self.len_chain, self.reducer)
self.left_wheel.ini_motor()
self.right_wheel = Wheel(1, '/dev/ttyS3', self.len_chain,
-self.reducer)
self.right_wheel.ini_motor()
self.dis_of_2wheels = 1.5
def __init__(self, speed=80, frequency=1000):
self.direction = Direction.Stop
self.robotspeed = speed
self.wheels = {}
self.wheels[Axle.FrontLeft] = Wheel(23, 22, self.robotspeed, frequency)
self.wheels[Axle.FrontRight] = Wheel(25, 24, self.robotspeed,
frequency)
self.wheels[Axle.BackLeft] = Wheel(27, 15, self.robotspeed, frequency)
self.wheels[Axle.BackRight] = Wheel(14, 13, self.robotspeed, frequency)
self.Stop()
def __init__(self, back_wheel_center, back_tire_radius, front_wheel_center,
front_tire_radius, body_height):
upper_left_point = Point(back_wheel_center.x,
back_wheel_center.y - body_height)
bottom_right_point = front_wheel_center
self.body = Rectangle(upper_left_point, bottom_right_point)
self.back_wheel = Wheel(back_wheel_center,
back_tire_radius * Car.WHEEL_TO_TIRE_RATIO,
back_tire_radius)
self.front_wheel = Wheel(front_wheel_center,
front_tire_radius * Car.WHEEL_TO_TIRE_RATIO,
front_tire_radius)
def __init__(self):
self.motor_controller = Adafruit_MotorHAT(i2c_address)
self.FL = Wheel(self.motor_controller, FL_id, trim[0], invert=True)
self.FR = Wheel(self.motor_controller, FR_id, trim[1], invert=True)
self.RL = Wheel(self.motor_controller, RL_id, trim[2])
self.RR = Wheel(self.motor_controller, RR_id, trim[3])
self.all_wheels = [self.FL, self.FR, self.RL, self.RR]
self.left_wheels = [self.FL, self.RL]
self.right_wheels = [self.FR, self.RR]
self.left_diag = [self.FL, self.RR]
self.right_diag = [self.FR, self.RL]
atexit.register(self.stop)
self.stop()
def __init__(self):
"""
"""
# engine rpm
self._rpm = 100 #rev/min
# vehicle mass
self.mass = 1550 #kg FORD
# current longitudinal speed
self.speed = 0 #m/s
# current acceleration
self.acceleration = 0 #m/s**2
# current gear in the gearbox
self.gear = 0 #pure
# drag resistance
self.drag_cd = 0.328 #pure FORD
# final ratio on the drive wheels
self.final_ratio = 3.61 #pure FORD
# cg height
self.cg_height = 1.0 #m
# wheelbase, distance between the front and rear wheels
self.wheelbase = 2.489 #m FORD
self.efficiency = 0.75
# gears-engine scale factors FORD
self.gear_ratios = [(3.583), (1.926), (1.206), (0.878), (0.689)] #pure
# curve for the rpm-torque relation in the engine
self.engine_rpm_torque_curve_params = optimize.curve_fit(
self.rpm_torque_function, (0, 100, 2000, 3000, 4000, 5000, 6000),
(10, 190, 230, 240, 250, 210, 180),
p0=[-1, 1, 150])[0]
#self.wheel_slip_longitudinal_force_curve_params = optimize.curve_fit(self.slip_longitudinal_force_function,
# (-100.1, -20, -10, 0, 10, 20, 100.1),
# (0, -4000, -6000, 0, 6000, 4000, 0),
# p0=[6000, 1e-3])[0]
self.max_gear_rpm = 5000 #rev/min
self.thrust = 1
self.wheels = [ # rear
Wheel(self.wheelbase * 0.5, drive=True),
Wheel(self.wheelbase * 0.5, drive=True),
# front
Wheel(self.wheelbase * 0.5, drive=False),
Wheel(self.wheelbase * 0.5, drive=False),
]
self.vis_speed = []
self.vis_forces = []
self.vis_res_forces = []
self.vis_gears = []
self.vis_engine_rpm = []
self.vis_engine_torques = []
def test_streets_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_streets_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset([Outcome("1, 2, 3", 17)])
assert wheel.get_bin(2).outcomes == frozenset([Outcome("1, 2, 3", 17)])
assert wheel.get_bin(3).outcomes == frozenset([Outcome("1, 2, 3", 17)])
def test_dozen_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_dozen_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset([Outcome("Dozen 1", 2)])
assert wheel.get_bin(13).outcomes == frozenset([Outcome("Dozen 2", 2)])
assert wheel.get_bin(36).outcomes == frozenset([Outcome("Dozen 3", 2)])
def test_column_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_column_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset([Outcome("Column 1", 2)])
assert wheel.get_bin(28).outcomes == frozenset([Outcome("Column 1", 2)])
assert wheel.get_bin(27).outcomes == frozenset([Outcome("Column 3", 2)])
def test_straight_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_straight_bets(wheel)
assert wheel.get_bin(0).outcomes == frozenset([Outcome("0", 35)])
assert wheel.get_bin(37).outcomes == frozenset([Outcome("00", 35)])
assert wheel.get_bin(3).outcomes == frozenset([Outcome("3", 35)])
def __init__(self, args):
'''Constructor'''
self.parser = msgParser.MsgParser()
self.state = carState.CarState()
self.control = carControl.CarControl()
self.state_size = 20
self.action_size = 3
self.model = LinearModel(args.replay_size, self.state_size,
self.action_size)
self.enable_training = args.enable_training
self.enable_exploration = args.enable_exploration
self.show_sensors = args.show_sensors
self.exploration_decay_steps = args.exploration_decay_steps
self.exploration_rate_start = args.exploration_rate_start
self.exploration_rate_end = args.exploration_rate_end
from wheel import Wheel
self.wheel = Wheel(args.joystick_nr, args.autocenter, args.gain,
args.min_level, args.max_level, args.min_force)
self.steer_lock = 0.785398
self.max_speed = 100
#from plotlinear import PlotLinear
#self.plot = PlotLinear(self.model, ['Speed', 'Angle', 'TrackPos'], ['Steer', 'Accel', 'Brake'])
if self.show_sensors:
from sensorstats import Stats
self.stats = Stats(inevery=8)
self.reset()
def testFlat(self):
testPressure = Wheel.BURST_PRESSURE / 2.0
wheel = Wheel()
wheel.pressure = testPressure
self.assertEqual(wheel.pressure, testPressure)
self.assertEqual(wheel.flat, False)
wheel.pressure = 0.0
self.assertEqual(wheel.flat, True)
def testSpecific(self):
testDiameter: float = 22.0
testPressure: float = Wheel.BURST_PRESSURE / 2.0
wheel = Wheel(diameter=testDiameter, pressure=testPressure)
self.assertEqual(wheel.pressure, testPressure)
self.assertEqual(wheel.diameter, testDiameter)
self.assertEqual(wheel.burst, False)
self.assertEqual(wheel.flat, False)
def test_line_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_line_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset(
[Outcome("1, 2, 3, 4, 5, 6", 5)])
assert wheel.get_bin(4).outcomes == frozenset(
[Outcome("1, 2, 3, 4, 5, 6", 5),
Outcome("4, 5, 6, 7, 8, 9", 5)])
def testBurst(self):
wheel = Wheel()
wheel.pressure = Wheel.BURST_PRESSURE / 2.0
self.assertEqual(wheel.flat, False)
self.assertEqual(wheel.burst, False)
wheel.pressure = Wheel.BURST_PRESSURE
self.assertEqual(wheel.pressure, 0.0)
self.assertEqual(wheel.flat, True)
self.assertEqual(wheel.burst, True)
wheel.pressure = Wheel.BURST_PRESSURE / 2.0
self.assertEqual(wheel.pressure, 0.0)
self.assertEqual(wheel.flat, True)
self.assertEqual(wheel.burst, True)
def main():
new_win = GraphWin("A Car", 700, 300)
# 1st wheel centered at 50,50 with radius 15
wheel_center_1 = Point(50, 50)
wheel_radius_1 = 15
tire_radius_1 = 0.6 * tire_radius_1
# 2nd wheel centered at 100,50 with radius 15
wheel_center_2 = Point(100, 50)
wheel_radius_2 = 15
tire_radius_2 = 0.6 * tire_radius_1
# rectangle with a height of 40
upper_left_point = Point(15, 55)
bottom_right_point = Point(75, 15)
wheel_1 = Wheel(wheel_center_1, 0.6 * tire_radius_1, tire_radius_1)
wheel_2 = Wheel(wheel_center_2, 0.6 * tire_radius_2, tire_radius_2)
body = Rectangle(upper_left_point, bottom_right_point)
# Set its color
wheel_1.set_color('OliveDrab1', 'Pink')
wheel_2.set_color('OliveDrab1', 'Pink')
body.setFill('Blue')
# And finally, draw it
wheel_1.draw(new_win)
wheel_2.draw(new_win)
body.draw(new_win)
car1 = Car(wheel_1, wheel_2, body)
car1.draw(new_win)
# make the car move on the screen
car1.animate(new_win, 1, 0, 400)
new_win.mainloop()
def test_even_money_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_even_money_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset([
Outcome("Low", 1),
Outcome("Odd", 1),
Outcome("Red", 1),
])
assert wheel.get_bin(24).outcomes == frozenset([
Outcome("High", 1),
Outcome("Even", 1),
Outcome("Black", 1),
])
def game_loop():
player = Player(mglobals.PLAYER)
wheel = Wheel()
player_ui = ui.PlayerUI()
event_ui = ui.EventUI()
player_ui.update(player.cash, player.heart, player.face)
msg_ui = ui.MsgUI()
utils.draw_board()
player.render()
player_ui.render()
while True:
event_ui.update(player.position)
if player.position in mglobals.CellTypes.MSG.value and player.round > 0:
msg_ui.update(player.position)
msg_ui.play()
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.quit()
quit()
if event.key == pygame.K_RETURN:
wheel.spin()
wheel.show()
# Move the player token across the board
for _ in range(wheel.number):
utils.draw_board()
player_ui.render()
player.advance(1)
event_ui.update(player.position)
if player.round > mglobals.ZERO:
sleep(0.4)
break
sleep(0.4)
pygame.display.update()
event_ui.play()
pygame.display.update()
mglobals.CLK.tick(30)
def test_run_the_wheel():
nrg = NonRandom([0, 37])
wheel = Wheel(nrg)
outcome_0 = Outcome("0", 35)
outcome_5 = Outcome("Five", 6)
outcome_00 = Outcome("00", 35)
wheel.add_outcome(0, outcome_0)
wheel.add_outcome(0, outcome_5)
wheel.add_outcome(37, outcome_00)
wheel.add_outcome(37, outcome_5)
bin = wheel.next()
assert bin.outcomes == frozenset([outcome_0, outcome_5])
bin = wheel.next()
assert bin.outcomes == frozenset([outcome_00, outcome_5])
def test_split_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_split_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset(
[Outcome("1, 2", 17), Outcome("1, 4", 17)])
assert wheel.get_bin(20).outcomes == frozenset([
Outcome("17, 20", 17),
Outcome("19, 20", 17),
Outcome("20, 21", 17),
Outcome("20, 23", 17),
])
assert wheel.get_bin(18).outcomes == frozenset([
Outcome("15, 18", 17),
Outcome("17, 18", 17),
Outcome("18, 21", 17),
])
def test_corner_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_corner_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset([Outcome("1, 2, 4, 5", 8)])
assert wheel.get_bin(4).outcomes == frozenset([
Outcome("1, 2, 4, 5", 8),
Outcome("4, 5, 7, 8", 8),
])
assert wheel.get_bin(7).outcomes == frozenset([
Outcome("4, 5, 7, 8", 8),
Outcome("7, 8, 10, 11", 8),
])
assert wheel.get_bin(8).outcomes == frozenset([
Outcome("4, 5, 7, 8", 8),
Outcome("5, 6, 8, 9", 8),
Outcome("7, 8, 10, 11", 8),
Outcome("8, 9, 11, 12", 8),
])
def test_build():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.build_bins(wheel)
wheel.get_bin(13).outcomes == frozenset([
Outcome("13", 35),
Outcome("10, 13", 17),
Outcome("13, 14", 17),
Outcome("13, 16", 17),
Outcome("13, 14, 15", 11),
Outcome("10, 11, 13, 14", 8),
Outcome("13, 14, 16, 17", 8),
Outcome("10, 11, 12, 13, 14, 15", 5),
Outcome("13, 14, 15, 16, 17, 18", 5),
Outcome("Dozen 1", 2),
Outcome("Column 1", 1),
Outcome("Low", 1),
Outcome("Odd", 1),
Outcome("Black", 1),
])
def __init__(self, args):
'''Constructor'''
self.parser = msgParser.MsgParser()
self.state = carState.CarState()
self.control = carControl.CarControl()
self.states = []
self.actions = []
self.filename = args.save_replay
assert self.filename is not None, "Use --save_replay <filename>"
from wheel import Wheel
self.wheel = Wheel(args.joystick_nr, args.autocenter, args.gain, args.min_level, args.max_level, args.min_force)
self.episode = 0
self.onRestart()
self.show_sensors = args.show_sensors
if self.show_sensors:
from sensorstats import Stats
self.stats = Stats(inevery=8)
def add_wheels(self, number):
for count in range(number):
self.wheels.append(Wheel())
import enum
from engine import Engine
from gearbox import GearBox
from wheel import Wheel
class CarType(enum.Enum):
sedan = "SEDAN"
wagon = "WAGON"
engine = Engine(100, 8000, 7000, 6200, 180, False)
gearbox = GearBox(6, "manual")
wheelList = [
Wheel(20, "summer", 2.6, 100),
Wheel(20, "summer", 2.6, 100),
Wheel(20, "summer", 2.6, 100),
Wheel(20, "summer", 2.6, 100)
]
class Car:
moving = False
def __init__(self, actualCarType):
self.actualCarType = actualCarType
def Car(self, actualCarType):
self.actualCarType = actualCarType
start_video = False
def broadcast_video():
video_loop = asyncio.new_event_loop()
video_loop.create_task(broadcast(video_loop))
video_loop.run_forever()
if start_video:
threading.Thread(target=broadcast_video).start()
###################################################
app = Quart(__name__)
svo = Servo()
drv = Wheel()
video_broadcast = None
@app.route('/', methods=['GET'])
async def index():
svo.angle(0, random.randint(0, 180))
await asyncio.sleep(0)
return ('', 200)
@app.route('/direction', methods=['POST'])
async def direction():
content = await request.get_json()
if content is not None:
def install_wheels(self):
for i in range(self.nr_of_wheels):
condition = random.randint(40-100)
self.wheels.append(Wheel(condition)) #here we append an instande of the class wheel in every iteration
def __init__(self, wheel_1, wheel_2, body):
self.wheel_1 = Wheel(wheel_center_1, wheel_radius_1, tire_radius_1)
self.wheel_2 = Wheel(wheel_center_2, wheel_radius_2, tire_radius_2)
self.body = Rectangle(upper_left_point, bottom_right_point)
