def main():
MA = MediumMotor("")
MB = LargeMotor("outB")
MC = LargeMotor("outC")
MD = MediumMotor("outD")
GY = GyroSensor("")
C3 = ColorSensor("")
C4 = ColorSensor("")
# change color sensor to color and define colors
C4.mode = 'COL-COLOR'
colors = ('', 'Black', 'Blue', 'Brown', 'Green', 'Yellow', 'Red', 'White')
# turn on motors forever
MB.run_forever(speed_sp=75)
MC.run_forever(speed_sp=75)
# while color sensor doesn't sense black. Wait until sensing black.
while C4.value() != 1:
print(colors[C4.value()])
sleep(0.005)
# after loop ends, brake motor B and C
MB.stop(stop_action="hold")
MC.stop(stop_action="hold")
def __init__(self,
jaw_motor_port: str = OUTPUT_A,
left_motor_port: str = OUTPUT_B,
right_motor_port: str = OUTPUT_C,
touch_sensor_port: str = INPUT_1,
color_sensor_port: str = INPUT_3,
ir_sensor_port: str = INPUT_4,
ir_beacon_channel: int = 1):
self.jaw_motor = MediumMotor(address=jaw_motor_port)
self.left_motor = LargeMotor(address=left_motor_port)
self.right_motor = LargeMotor(address=right_motor_port)
self.tank_driver = MoveTank(left_motor_port=left_motor_port,
right_motor_port=right_motor_port,
motor_class=LargeMotor)
self.steer_driver = MoveSteering(left_motor_port=left_motor_port,
right_motor_port=right_motor_port,
motor_class=LargeMotor)
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.color_sensor = ColorSensor(address=color_sensor_port)
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.speaker = Sound()
self.roaring = False
self.walk_speed = self.NORMAL_WALK_SPEED
def __init__(self, sensorList=[]):
try:
self.tank = MoveTank(OUTPUT_B, OUTPUT_C)
self.outputList = [OUTPUT_B, OUTPUT_C]
except:
self.tank = None
try:
self.cs = ColorSensor()
except:
self.cs = None
try:
self.gyro = GyroSensor()
except:
self.gyro = None
try:
self.ultrasonicSensor = UltrasonicSensor()
except:
self.ultrasonicSensor = None
try:
self.large = LargeMotor(OUTPUT_D)
self.outputList.append(OUTPUT_D)
except:
self.large = None
try:
self.medium = MediumMotor(OUTPUT_D)
self.outputList.append(OUTPUT_D)
except:
self.medium = None
def __init__(self, *args, **kwargs):
self.exposed_candy_loader = MediumMotor(OUTPUT_A)
self.exposed_candy_thrower = MediumMotor(OUTPUT_B)
self.exposed_left_cs = ColorSensor(INPUT_1)
self.exposed_right_cs = ColorSensor(INPUT_2)
super().__init__(*args, **kwargs)
def __init__(self, baseSpeed=500, dt=50):
self.leftMotor = LargeMotor(OUTPUT_C)
self.rightMotor = LargeMotor(OUTPUT_A)
self.steeringDrive = MoveSteering(OUTPUT_C, OUTPUT_A)
self.craneMotor = MediumMotor(OUTPUT_B)
self.baseSpeed = baseSpeed
self.dt = dt
def main():
Sound.speak("").wait()
MA = MediumMotor("")
MB = LargeMotor("outB")
MC = LargeMotor("outC")
MD = MediumMotor("")
GY = GyroSensor("")
C3 = ColorSensor("")
C4 = ColorSensor("")
GY.mode = 'GYRO-ANG'
GY.mode = 'GYRO-RATE'
GY.mode = 'GYRO-ANG'
tank_drive = MoveTank(OUTPUT_B, OUTPUT_C)
loop_gyro = 0
gyro_adjust = 1
# change this to whatever speed what you want
left_wheel_speed = -300
right_wheel_speed = -300
# change the loop_gyro verses the defined value argument to however far you want to go
# if Gyro value is the same as the starting value, go straight, if more turn right, if less turn left
# change the value to how far you want the robot to go
while MB.position > -160:
if GY.value() == 0:
left_wheel_speed = -300
right_wheel_speed = -300
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
gyro_adjust = 12
else:
if GY.value() > 0:
correct_rate = abs(
GY.value()
) # This captures the gyro value at the beginning of the statement
left_wheel_speed = left_wheel_speed + gyro_adjust
right_wheel_speed = right_wheel_speed - gyro_adjust
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
left_wheel_speed = -300
right_wheel_speed = -300
if abs(
GY.value()
) > correct_rate: # If gyro value has worsened despite the correction then change the adjust variable for next time
gyro_adjust = gyro_adjust + 1
else:
correct_rate = abs(
GY.value()) # Same idea as the other if statement
right_wheel_speed = right_wheel_speed + gyro_adjust
left_wheel_speed = left_wheel_speed - gyro_adjust
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
left_wheel_speed = -300
right_wheel_speed = -300
if abs(GY.value()) > correct_rate:
gyro_adjust = gyro_adjust + 1
# stop all motors
MB.stop(stop_action="hold")
MC.stop(stop_action="hold")
def __init__(self,
left_foot_motor_port: str = OUTPUT_B,
right_foot_motor_port: str = OUTPUT_C,
bazooka_blast_motor_port: str = OUTPUT_A,
touch_sensor_port: str = INPUT_1,
color_sensor_port: str = INPUT_3,
ir_sensor_port: str = INPUT_4,
ir_beacon_channel: int = 1):
super().__init__(left_motor_port=left_foot_motor_port,
right_motor_port=right_foot_motor_port,
polarity=Motor.POLARITY_NORMAL,
speed=1000,
channel=ir_beacon_channel)
self.tank_driver = MoveTank(left_motor_port=left_foot_motor_port,
right_motor_port=right_foot_motor_port,
motor_class=LargeMotor)
self.bazooka_blast_motor = MediumMotor(
address=bazooka_blast_motor_port)
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.color_sensor = ColorSensor(address=color_sensor_port)
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.leds = Leds()
self.speaker = Sound()
def __init__(self, motor_address=OUTPUT_D, us_sensor_address=INPUT_2, start_open=True):
self.claw_motor = MediumMotor(motor_address)
self.eyes = UltrasonicSensor(us_sensor_address)
if start_open and not self.is_open():
self.open()
elif not start_open and self.is_open():
self.close()
def __init__(self):
super().__init__()
self.leds = Leds()
self.motorOne = LargeMotor(OUTPUT_C)
self.motorTwo = LargeMotor(OUTPUT_B)
self.motorThree = MediumMotor(OUTPUT_A)
def __init__(self):
self.shutdown = False
self.flipper = LargeMotor(OUTPUT_A)
self.turntable = LargeMotor(OUTPUT_B)
self.colorarm = MediumMotor(OUTPUT_C)
self.color_sensor = ColorSensor()
self.color_sensor.mode = self.color_sensor.MODE_RGB_RAW
self.infrared_sensor = InfraredSensor()
self.init_motors()
self.state = ['U', 'D', 'F', 'L', 'B', 'R']
self.rgb_solver = None
signal.signal(signal.SIGTERM, self.signal_term_handler)
signal.signal(signal.SIGINT, self.signal_int_handler)
filename_max_rgb = 'max_rgb.txt'
if os.path.exists(filename_max_rgb):
with open(filename_max_rgb, 'r') as fh:
for line in fh:
(color, value) = line.strip().split()
if color == 'red':
self.color_sensor.red_max = int(value)
log.info("red max is %d" % self.color_sensor.red_max)
elif color == 'green':
self.color_sensor.green_max = int(value)
log.info("green max is %d" %
self.color_sensor.green_max)
elif color == 'blue':
self.color_sensor.blue_max = int(value)
log.info("blue max is %d" % self.color_sensor.blue_max)
def __init__(self,
medium_motor=OUTPUT_A,
left_motor=OUTPUT_C,
right_motor=OUTPUT_B):
RemoteControlledTank.__init__(self, left_motor, right_motor)
self.medium_motor = MediumMotor(medium_motor)
self.medium_motor.reset()
def __init__(self,
drive_motor_port=OUTPUT_B,
strike_motor_port=OUTPUT_D,
steer_motor_port=OUTPUT_A,
drive_speed_pct=60):
self.drive_motor = LargeMotor(drive_motor_port)
self.strike_motor = LargeMotor(strike_motor_port)
self.steer_motor = MediumMotor(steer_motor_port)
self.speaker = Sound()
STEER_SPEED_PCT = 30
self.remote = InfraredSensor()
self.remote.on_channel1_top_left = self.make_move(self.drive_motor, drive_speed_pct)
self.remote.on_channel1_bottom_left = self.make_move(self.drive_motor, drive_speed_pct * -1)
self.remote.on_channel1_top_right = self.make_move(self.steer_motor, STEER_SPEED_PCT)
self.remote.on_channel1_bottom_right = self.make_move(self.steer_motor, STEER_SPEED_PCT * -1)
self.shutdown_event = Event()
self.mrc = MonitorRemoteControl(self)
# Register our signal_term_handler() to be called if the user sends
# a 'kill' to this process or does a Ctrl-C from the command line
signal.signal(signal.SIGTERM, self.signal_term_handler)
signal.signal(signal.SIGINT, self.signal_int_handler)
def __init__(self):
"""
Performs Alexa Gadget initialization routines and ev3dev resource allocation.
"""
super().__init__()
# Robot state
self.patrol_mode = False
self.enemy_not_detected = True
print("+++++ self.patrol_mode = {} y self.enemy_not_detected = {}".
format(self.patrol_mode, self.enemy_not_detected))
self.positionX = 0
self.positionY = 0
self.direction = ['forward', 'right', 'backward', 'left']
self.offset = [0, 1, 0, -1]
self.index = 0
self.pointing = self.direction[self.index]
# Connect two large motors on output ports B and C
self.drive = MoveTank(OUTPUT_B, OUTPUT_C)
self.weapon = MediumMotor(OUTPUT_A)
self.sound = Sound()
self.leds = Leds()
self.ir = InfraredSensor()
# Start threads
threading.Thread(target=self._patrol_thread, daemon=True).start()
threading.Thread(target=self._proximity_thread, daemon=True).start()
def __init__(self):
"""
Performs Alexa Gadget initialization routines and ev3dev resource allocation.
"""
super().__init__()
# Gadget state
self.in_progress = False
# Ev3dev initialization
self.leds = Leds()
self.sound = Sound()
self.drive = MoveTank(OUTPUT_B, OUTPUT_A)
self.stick = MediumMotor(OUTPUT_C)
self.cs = ColorSensor(INPUT_4)
self.cs.mode = 'COL-REFLECT'
self.floor_light = self.cs.value()
print("floor light intensity = {}".format(self.floor_light))
self.speed = 20
self.kickAngle = 170
paho.Client.connected_flag = False
self.client = paho.Client()
self.client.loop_start()
self.client.on_connect = self.mqtt_connected
self.client.connect('broker.hivemq.com', 1883)
while not self.client.connected_flag:
time.sleep(1)
self.client.subscribe('/hockeybot/game/over')
self.client.on_message = self.mqtt_on_message
# Start threads
threading.Thread(target=self.check_for_obstacles_thread,
daemon=True).start()
class AutoDrive:
def __init__(self, left_motor_port, right_motor_port, infra_mode,
ultra_mode):
self.__moveSteering = MoveSteering(left_motor_port, right_motor_port)
self.__mediumMotor = MediumMotor()
self.__ir = InfraredSensor()
self.__ir.mode = infra_mode
self.__us = UltrasonicSensor()
self.__us.mode = ultra_mode
def __run_forward(self):
self.__moveSteering.on(0, 30)
def __run_backward_rotations(self, rotations):
self.__moveSteering.on_for_rotations(0, 20, -rotations)
def __stop(self):
self.__moveSteering.off()
def __back_and_turn(self, steering):
self.__moveSteering.on_for_rotations(-steering, 20, -1)
def __scan_around_distance(self):
proximities = {}
distance = 0
index = 0
for deg in [-90, 30, 30, 30, 30, 30, 30]:
self.__mediumMotor.on_for_degrees(10, deg)
distance = self.__ir.proximity
proximities[-90 + index * 30] = distance
index += 1
time.sleep(1)
self.__mediumMotor.on_for_degrees(10, -90)
# print("%s" % proximities)
return proximities
def __find_clear_direction(self, proximitiesDic):
max_distance = max(list(proximitiesDic.values()))
direction = list(proximitiesDic.keys())[list(
proximitiesDic.values()).index(max_distance)]
#print("%d" % direction)
steering = self.__convert_direction_to_steering(direction)
return steering
def __convert_direction_to_steering(self, direction):
return 5 * direction / 9
def __ultrasonic_distance(self):
return self.__us.distance_centimeters
def run(self):
self.__run_forward()
block_distance = self.__ultrasonic_distance()
if (block_distance < 20):
self.__stop()
around_distance = self.__scan_around_distance()
steering = self.__find_clear_direction(around_distance)
self.__run_backward_rotations(0.5)
self.__back_and_turn(steering)
class Ev3rstorm(IRBeaconRemoteControlledTank):
def __init__(
self,
left_foot_motor_port: str = OUTPUT_B, right_foot_motor_port: str = OUTPUT_C,
bazooka_blast_motor_port: str = OUTPUT_A,
touch_sensor_port: str = INPUT_1, color_sensor_port: str = INPUT_3,
ir_sensor_port: str = INPUT_4, ir_beacon_channel: int = 1):
super().__init__(
left_motor_port=left_foot_motor_port, right_motor_port=right_foot_motor_port, motor_class=LargeMotor,
ir_sensor_port=ir_sensor_port, ir_beacon_channel=ir_beacon_channel)
self.bazooka_blast_motor = MediumMotor(address=bazooka_blast_motor_port)
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.color_sensor = ColorSensor(address=color_sensor_port)
self.screen = Display()
self.speaker = Sound()
def blast_bazooka_if_touched(self):
if self.touch_sensor.is_pressed:
if self.color_sensor.ambient_light_intensity < 5: # 15 not dark enough
self.speaker.play_file(
wav_file='/home/robot/sound/Up.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(
speed=100,
rotations=-3,
brake=True,
block=True)
else:
self.speaker.play_file(
wav_file='/home/robot/sound/Down.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(
speed=100,
rotations=3,
brake=True,
block=True)
self.touch_sensor.wait_for_released()
def main(self, driving_speed: float = 100):
self.screen.image_filename(
filename='/home/robot/image/Target.bmp',
clear_screen=True)
self.screen.update()
while True:
self.drive_once_by_ir_beacon(speed=driving_speed)
self.blast_bazooka_if_touched()
def __init__(self, left_motor_port, right_motor_port, infra_mode,
ultra_mode):
self.__moveSteering = MoveSteering(left_motor_port, right_motor_port)
self.__mediumMotor = MediumMotor()
self.__ir = InfraredSensor()
self.__ir.mode = infra_mode
self.__us = UltrasonicSensor()
self.__us.mode = ultra_mode
def __init__(self):
self.server_address = (str(sys.argv[1]), 5000)
self.sensor = InfraredSensor()
self.motor = MediumMotor(OUTPUT_D)
self.drive_motor = MoveTank(OUTPUT_B, OUTPUT_C)
self.turn_motor = MoveSteering(OUTPUT_B, OUTPUT_C)
self.moved = 0
self.turned = 0
class EV3D4WebControlled(WebControlledTank):
def __init__(self,
medium_motor=OUTPUT_A,
left_motor=OUTPUT_C,
right_motor=OUTPUT_B):
WebControlledTank.__init__(self, left_motor, right_motor)
self.medium_motor = MediumMotor(medium_motor)
self.medium_motor.reset()
def __init__(self):
self.angleToRunTo = 0
self.motorArm = MediumMotor(OUTPUT_B)
self.CurrentAngle = 0
self.motorAngle = 0
self.motorDestinationAngle = 0
self.Hold = False
self.gainAngle = 0
def __init__(self):
super().__init__()
# initialize all of the motors
print('Initializing devices')
self.leds = Leds()
self.motor_hand = LargeMotor(address='outA')
self.motor_claw = MediumMotor(address='outC')
def __init__(self, left_motor_port, right_motor_port, infra_sensor_mode,
color_sensor_mode):
self.__movesteering = MoveSteering(left_motor_port, right_motor_port)
self.__mediummotor = MediumMotor()
self.__cs = ColorSensor()
self.__cs.mode = color_sensor_mode
self.__ir = InfraredSensor()
self.__ir.mode = infra_sensor_mode
def __init__(self):
self.leds = Leds()
self.arm_position = ArmPosition.CONTRACT
self.color_arm = MediumMotor(OUTPUT_A)
self.color_sensor = ColorSensor()
self.color_scaned = ColorScanOptions.NONE
self.sound = Sound()
def __init__(self,
left_motor_port=OUTPUT_B,
right_motor_port=OUTPUT_C,
medium_motor_port=OUTPUT_A):
MoveTank.__init__(self, left_motor_port, right_motor_port)
self.set_polarity(MediumMotor.POLARITY_NORMAL)
self.medium_motor = MediumMotor(medium_motor_port)
self.sound = Sound()
def main():
# start sensor and motor definitions
Sound.speak("").wait()
MA = MediumMotor("")
MB = LargeMotor("outB")
MC = LargeMotor("outC")
MD = MediumMotor("")
GY = GyroSensor("")
C3 = ColorSensor("")
C4 = ColorSensor("")
# end sensor and motor definitions
# start calibration
GY.mode = 'GYRO-ANG'
GY.mode = 'GYRO-RATE'
GY.mode = 'GYRO-ANG'
# end calibration
# The following line would be if we used tank_drive
# tank_drive = MoveTank(OUTPUT_B, OUTPUT_C)
# start definition of driving parameters
loop_gyro = 0
starting_value = GY.value()
# end definition of driving parameters
# set initial speed parameters
speed = 20
adjust = 1
# change 999999999999 to however you want to go
while loop_gyro < 999999999999:
# while Gyro value is the same as the starting value, then go straigt.
while GY.value() == starting_value:
left_wheel_speed = speed
right_wheel_speed = speed
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
return
# while greater than starting value, then go left.
while GY.value() > starting_value:
left_wheel_speed = speed - adjust
right_wheel_speed = speed
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
return
# while less than starting value, then go right.
while GY.value() < starting_value:
left_wheel_speed = speed + adjust
right_wheel_speed = speed
MB.run_forever(speed_sp=left_wheel_speed)
MC.run_forever(speed_sp=right_wheel_speed)
return
return
class Sweep3r(IRBeaconRemoteControlledTank):
def __init__(self,
left_foot_motor_port: str = OUTPUT_B,
right_foot_motor_port: str = OUTPUT_C,
medium_motor_port: str = OUTPUT_A,
touch_sensor_port: str = INPUT_1,
color_sensor_port: str = INPUT_3,
ir_sensor_port: str = INPUT_4,
ir_beacon_channel: int = 1):
super().__init__(left_motor_port=left_foot_motor_port,
right_motor_port=right_foot_motor_port,
ir_sensor_port=ir_sensor_port,
ir_beacon_channel=ir_beacon_channel)
self.medium_motor = MediumMotor(address=medium_motor_port)
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.color_sensor = ColorSensor(address=color_sensor_port)
self.ir_sensor = InfraredSensor(address=ir_sensor_port)
self.ir_beacon_channel = ir_beacon_channel
self.speaker = Sound()
def drill(self, speed: float = 100):
while True:
if self.ir_sensor.beacon(channel=self.ir_beacon_channel):
self.medium_motor.on_for_rotations(speed=speed,
rotations=2,
block=True,
brake=True)
def move_when_touched(self):
while True:
if self.touch_sensor.is_pressed:
self.tank_driver.on_for_seconds(left_speed=100,
right_speed=-100,
seconds=2,
brake=True,
block=True)
def move_when_see_smothing(self):
while True:
if self.color_sensor.reflected_light_intensity > 30:
self.tank_driver.on_for_seconds(left_speed=-100,
right_speed=100,
seconds=2,
brake=True,
block=True)
def main(self, speed: float = 100):
Thread(target=self.move_when_touched).start()
Thread(target=self.move_when_see_smothing).start()
Thread(target=self.drill).start()
self.keep_driving_by_ir_beacon(speed=speed)
class Ev3rstorm(RemoteControlledTank):
def __init__(self,
left_foot_motor_port: str = OUTPUT_B,
right_foot_motor_port: str = OUTPUT_C,
bazooka_blast_motor_port: str = OUTPUT_A,
touch_sensor_port: str = INPUT_1,
color_sensor_port: str = INPUT_3,
ir_beacon_channel: int = 1):
super().__init__(left_motor_port=left_foot_motor_port,
right_motor_port=right_foot_motor_port,
polarity=Motor.POLARITY_NORMAL,
speed=1000,
channel=ir_beacon_channel)
self.bazooka_blast_motor = MediumMotor(
address=bazooka_blast_motor_port)
self.touch_sensor = TouchSensor(address=touch_sensor_port)
self.color_sensor = ColorSensor(address=color_sensor_port)
self.screen = Display()
self.speaker = Sound()
def blast_bazooka_whenever_touched(self):
while True:
if self.touch_sensor.is_pressed:
if self.color_sensor.ambient_light_intensity < 5: # 15 not dark enough
self.speaker.play_file(
wav_file='/home/robot/sound/Up.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(speed=100,
rotations=-3,
brake=True,
block=True)
else:
self.speaker.play_file(
wav_file='/home/robot/sound/Down.wav',
volume=100,
play_type=Sound.PLAY_WAIT_FOR_COMPLETE)
self.bazooka_blast_motor.on_for_rotations(speed=100,
rotations=3,
brake=True,
block=True)
self.touch_sensor.wait_for_released()
def main(self):
self.screen.image_filename(filename='/home/robot/image/Target.bmp',
clear_screen=True)
self.screen.update()
Thread(target=self.blast_bazooka_whenever_touched, daemon=True).start()
super().main() # RemoteControlledTank.main()
def __init__(self, medium_motor, left_motor, right_motor):
RemoteControlledTank.__init__(self, left_motor, right_motor)
self.medium_motor = MediumMotor(medium_motor)
if not self.medium_motor.connected:
log.error("%s is not connected" % self.medium_motor)
sys.exit(1)
self.medium_motor.reset()
class Claw:
def __init__(self, output):
self.claw = MediumMotor(output)
def up(self):
self.claw.on_for_degrees(30, 360)
def down(self):
self.claw.on_for_degrees(30, -360)
def test_medium_motor_write(self):
clean_arena()
populate_arena([('medium_motor', 0, 'outA')])
m = MediumMotor()
self.assertEqual(m.speed_sp, 0)
m.speed_sp = 500
self.assertEqual(m.speed_sp, 500)
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)5s: %(message)s')
log=logging.getLogger(__name__)
log.info('Stair climber starting......')
# define the touch sensor
ts = TouchSensor(INPUT_3)
# define the gyro sensor
gy = GyroSensor(INPUT_2)
# define the large motor on port B
lm_move = LargeMotor(OUTPUT_B)
# define the large motor on port D
lm_lifter = LargeMotor(OUTPUT_D)
# define the midium motor on port A
mm_move = MediumMotor(OUTPUT_A)
# define the button
btn = Button()
# define lcd display
lcd = Display()
# define sound
snd = Sound()
# define the steps to go, initial value is 0
steps = 1
# Declare function for one step
def oneStep():
