class RemoteCar(): def __init__(self): self._backMotor = Motor(forward=BACK_PIN_1, backward=BACK_PIN_2) self._frontMotor = Motor(forward=FRONT_PIN_1, backward=FRONT_PIN_2) self.stop() def drive(self, dir): if dir == 1: self._backMotor.forward() elif dir == -1: self._backMotor.backward() else: self._backMotor.stop() def turn(self, dir): if dir == 1: # turn right self._frontMotor.backward() elif dir == -1: self._frontMotor.forward() else: self._frontMotor.stop() def stop(self): self.drive(0) self.turn(0)
class Car: def __init__(self): self.drive_motor = Motor(9, 10) self.turn_motor = Motor(8, 7) def forward(self, value=1): self.drive_motor.forward(value) def backward(self, value=1): self.drive_motor.backward(value) def left(self, value=1): self.turn_motor.forward(value) def right(self, value=1): self.turn_motor.backward(value) def drive(self, x, y): x = min(max(-1, x), 1) # cap X between -1 and 1 y = min(max(-1, y), 1) # cap Y between -1 and 1 if y > 0: self.forward(y) else: self.backward(-y) if x > 0: self.right(x) else: self.left(-x) def stop(self): self.drive_motor.stop() self.turn_motor.stop()
class motor_driver: def __init__(self): self.speed = 0.5 self.motor = Motor(forward=4, backward=14) rospy.init_node('motor_listener', anonymous=True) rospy.Subscriber('/cmd_vel', Twist, self.callback) def callback(self, data): rospy.loginfo(data.linear.x) self.speed = self.pre_process_speed(data.linear.x) # print(self.speed) def pre_process_speed(self, speed): if abs(speed) > 1: speed = speed / abs(speed) return round(speed, 2) def drive_motor(self): # print(self.speed) if self.speed > 0: self.motor.forward(self.speed) elif self.speed < 0: self.motor.backward(abs(self.speed)) else: self.motor.stop()
class PirateRobot(object): # pins for control # (FW, BW) def __init__(self, lpins=(22, 27), rpins=(23, 24)): # pines self.left_pins = lpins self.right_pins = rpins # init hardware and pins self.left_motor = Motor(self.left_pins[0], self.left_pins[1]) self.right_motor = Motor(self.right_pins[0], self.right_pins[1]) def left(self, vel): if vel > 0: self.left_motor.forward(vel) else: self.left_motor.backward(abs(vel)) def right(self, vel): if vel > 0: self.right_motor.forward(vel) else: self.right_motor.backward(abs(vel)) def drive(self, linear, angular): # differential drive left_vel = (linear - angular) / 2 right_vel = (linear + angular) / 2 self.left(left_vel) self.right(right_vel)
class Robot(object): """ Lowest possible abstraction of our robots. """ def __init__(self, left_a_pin, left_b_pin, right_a_pin, right_b_pin): self.left_a_pin = left_a_pin self.left_b_pin = left_b_pin self.right_a_pin = right_a_pin self.right_b_pin = right_b_pin self.left_motor = Motor(self.left_a_pin, self.left_b_pin, pwm=True) self.right_motor = Motor(self.right_a_pin, self.right_b_pin, pwm=True) self.left_motor.stop() self.right_motor.stop() def move(self, left_drive, right_drive): LOGGER.debug("left_drive: {}; right_drive: {}".format( left_drive, right_drive)) if left_drive >= 0: self.left_motor.forward(left_drive) else: self.left_motor.backward(-left_drive) if right_drive >= 0: self.right_motor.forward(right_drive) else: self.right_motor.backward(-right_drive) def stop(self): self.left_motor.stop() self.right_motor.stop()
class DcMotor: def __init__(self, name, pinForward, pinBackward, frontDuration, backDuration, initialState, ee): self.name = name self.actualPosition = '' self.pinForward = pinForward self.pinBackward = pinBackward self.frontDuration = frontDuration self.backDuration = backDuration self.initialState = initialState self.ee = ee self.motor = Motor(pinForward, pinBackward) self.move(initialState) def move(self, position): if position not in ['forward', 'backward']: Exception("position must by either 'forward' or 'backward'") angle = 100 if position == 'forward' else 0 percent = 100 if position == 'forward' else 0 self.ee.emit('move', self.name, angle, percent) if position == 'forward': self.motor.forward() time.sleep(self.frontDuration) else: self.motor.backward() time.sleep(self.backDuration) self.actualPosition = position self.motor.stop()
class Rudder: scale = 10 def __init__(self): from gpiozero import Motor self.motor = Motor(17, 27) self._value = 0 def register(self, vechicle): vechicle.commands['rudder'].append(self.rudder) vechicle.commands['stop'].append(self.stop) vechicle.sensors['rudder'] = self.value def value(self): return self._value def rudder(self, delta): value = self._value + delta if value > self.scale or value < -self.scale: return self._value = value if value > 0: self.motor.forward(value / self.scale) elif value < 0: self.motor.backward(-value / self.scale) else: self.motor.stop() def stop(self, *args): self._value = 0 self.motor.stop()
class Throttle: scale = 10 def __init__(self): from gpiozero import Motor self.motor = Motor(23, 24) self._value = 0 self._damping_task = None def register(self, vechicle): self._loop = vechicle.loop vechicle.commands['throttle'].append(self.throttle) vechicle.commands['stop'].append(self.stop) vechicle.sensors['throttle'] = self.value def value(self): return self._value def throttle(self, delta): if self._damping_task: self._damping_task.cancel() self._damping_task = None value = self._value + delta if value > self.scale or value < -self.scale: return if value >= 0: if delta > 0 and value > 0: self._damping_task = DampingForward(self) asyncio.ensure_future(self._damping_task.run(value, 5), loop=self._loop) else: self._value = value self.motor.forward(value / self.scale) elif value < 0: self._value = value self.motor.backward(-value / self.scale) else: self.motor.stop() def stop(self, *args): if self._damping_task: self._damping_task.cancel() self._damping_task = None if self._value > 0: self._value = -1 self.motor.backward(1) else: self._value = 1 self.motor.forward(1) time.sleep(0.1) self._value = 0 self.motor.stop()
class Persiana(object): def __init__(self, forward_pin_gpio, backward_pin_gpio, name="GPIO", open_direction_backward=True, time_open=5): """ Contructor de la clase persiana Args: forward_pin_gpio (int): Pin GPIO para el motor 1 backward_pin_gpio (int): Pin GPIO para el motor 1 name (str, optional): Nombre que tendrá el dispositivo. Defaults to "GPIO". open_direction_backward (bool, optional): Sirve para determinar hacia que dirección se abrirá la persiana. Defaults to True. time_open (int, optional): Tiempo que tarda en abrir la persiana, que será el mismo para abrir y cerrar. Defaults to 5. """ self.motor = Motor(forward=forward_pin_gpio, backward=backward_pin_gpio) self.name = name if name != "GPIO" else "GPIO " + "{},{}".format( forward_pin_gpio, backward_pin_gpio) self.open_direction_backward = open_direction_backward self.time_open = time_open def open(self): """ Abre la persiana con el tiempo establecido """ if self.open_direction_backward: self.motor.backward() else: self.motor.forward() sleep(self.time_open) def close(self): """ Cierra la persiana con el tiemp oestablecido. """ if self.open_direction_backward: self.motor.forward() else: self.motor.backward() sleep(self.time_open) def on(self): """ Wrapper para que cuando se llame el método on, se abra """ self.open() def off(self): """ Wrapper para que cuando se llame el método off, se cierre """ self.close()
class CarMotorXiaoR(): def __init__(self): self.motor_lx = Motor(16, 19) self.motor_rx = Motor(21, 26) self.enable_lx = DigitalOutputDevice(13) self.enable_rx = DigitalOutputDevice(20) self.enable_lx.on() self.enable_rx.on() def forward(self): self.motor_rx.forward() self.motor_lx.forward() def backward(self): self.motor_rx.backward() self.motor_lx.backward() def stop(self): self.motor_rx.stop() self.motor_lx.stop() def right(self): self.motor_rx.forward() self.motor_lx.backward() def left(self): self.motor_lx.forward() self.motor_rx.backward()
class motor: def __init__(self, motorA, motorB, motorC, motorD, pwmBool = True): self.motorE = Motor(motorA, motorB) self.motorD = Motor(motorC, motorD) self.motorE.pwm(pwmBool) self.motorD.pwm(pwmBool) self.pwm = 0.5 def andarFrente(self, tempo = 1): pwm = 0.5 #pwm em 50% self.motorE.forward(pwm) self.motorD.forward(pwm) sleep(tempo) def andarTras(self, tempo = 1): self.motorE.backward(self.pwm) self.motorD.backward(self.pwm) sleep(tempo) def girarEsquerda(self, angulo = 90): self.motorE.backward(self.pwm) self.motorD.forward(self.pwm) sleep(angulo/360) def girarDireita(self, angulo = 90): self.motorE.forward(self.pwm) self.motorD.backward(self.pwm) sleep(angulo/360) def parar(self, tempo = 1): self.motorE.stop() self.motorD.stop() sleep(tempo)
class MotorControl: def __init__(self, motor1Pin1, motor1Pin2, motor2Pin1, motor2Pin2): self.motor1 = Motor(forward=motor1Pin1, backward=motor1Pin2) self.motor2 = Motor(forward=motor2Pin1, backward=motor2Pin2) def moveForward(self): self.motor2.forward() self.motor1.forward() def moveBackward(self): self.motor2.backward() self.motor1.backward() def stop(self): self.motor1.stop() self.motor2.stop() def turnLeft(self): self.motor1.stop() self.motor2.forward() def turnReft(self): self.motor2.stop() self.motor1.forward() def turnLeftHard(self): self.motor1.backward() self.motor2.forward() def turnReftHard(self): self.motor2.backward() self.motor1.forward()
class Omniwheel: def __init__(self, pins, angle, modifier): self.pins = pins self.motor = Motor(*pins) self.angle = angle self.tanAngle = (angle + 90) % 360 self.modifier = modifier def set_speed(self, speed): if speed > 0: self.motor.forward(speed * self.modifier) else: self.motor.backward(-speed * self.modifier) def set(self, speed, angle, turning): m = speed * math.cos(math.radians(self.angle - angle)) + turning
class MecRobot(): def __init__(self): self.frontLeft = Motor(6, 13) self.frontRight = Motor(9, 11) self.rearLeft = Motor(20, 21) self.rearRight = Motor(17, 27) # Motors are reversed. If you find your robot going backwards, set this to 1 self.motor_multiplier = -1 self.red = LED(16) self.red.blink() self.LineFollowingError = -1 def set_speeds(self,power_left, power_right): # If one wants to see the 'raw' 0-100 values coming in # print("source left: {}".format(power_left)) # print("source right: {}".format(power_right)) # Take the 0-100 inputs down to 0-1 and reverse them if necessary power_left = (self.motor_multiplier * power_left) / 100 power_right = (self.motor_multiplier * power_right) / 100 # Print the converted values out for debug # print("left: {}".format(power_left)) # print("right: {}".format(power_right)) # If power is less than 0, we want to turn the motor backwards, otherwise turn it forwards if power_left < 0: #print("power_left ",power_left) self.frontLeft.forward(-power_left) self.rearLeft.forward(-power_left) else: #print("power_left ",power_left) self.frontLeft.backward(power_left) self.rearLeft.backward(power_left) if power_right < 0: self.frontRight.forward(-power_right) self.rearRight.forward(-power_right) else: self.frontRight.backward(power_right) self.rearRight.backward(power_right) def stop_motors(self): """ As we have a motor hat, stop the motors using their motors call """ # Turn both motors off self.frontLeft.stop() self.frontRight.stop() self.rearLeft.stop() self.rearRight.stop()
class CoopDoor(): def __init__(self, motor_forward, motor_backward, open_sensor, close_sensor, max_time_open=60, max_time_close=45): self.max_time_open = max_time_open self.max_time_close = max_time_close self.motor = Motor(motor_forward, motor_backward) self.open_sensor = DigitalInputDevice(open_sensor) self.close_sensor = DigitalInputDevice(close_sensor) self.determine_state() def close(self): start = perf_counter() self.determine_state() log.debug(f"door.close() state: {self.state}") if self.state != State.CLOSE: while (self.state != State.CLOSE) \ & ((perf_counter() - start) < self.max_time_close): self.motor.forward() self.determine_state() else: self.motor.stop() return self.state def open(self): start = perf_counter() self.determine_state() log.debug(f"door.open() state: {self.state}") if self.state != State.OPEN: while (self.state != State.OPEN) \ & ((perf_counter() - start) < self.max_time_open): self.motor.backward() self.determine_state() else: self.motor.stop() return self.state def determine_state(self): if self.open_sensor.value == 0: self.state = State.OPEN elif self.close_sensor.value == 0: self.state = State.CLOSE else: self.state = State.INTERMEDIATE return self.state
class SmartCarMotorController(DualMotorController): def __init__(self): super(SmartCarMotorController, self).__init__() self._left_motor = Motor(4, 14) self._right_motor = Motor(18, 17) def set_speeds(self, speed_left_m_per_sec, speed_right_m_per_sec): print(str(speed_left_m_per_sec), str(speed_right_m_per_sec)) speed_left = speed_left_m_per_sec / MAX_SPEED_M_PER_SEC speed_right = speed_right_m_per_sec / MAX_SPEED_M_PER_SEC if speed_left < 0: self._left_motor.backward(-speed_left * LEFT_REV_FACTOR) else: self._left_motor.forward(speed_left * LEFT_FWD_FACTOR) if speed_right < 0: self._right_motor.backward(-speed_right * RIGHT_REV_FACTOR) else: self._right_motor.forward(speed_right * RIGHT_FWD_FACTOR)
def test_backward(self): """ 後退テスト """ # 接続ピン PIN_AIN1 = 6 PIN_AIN2 = 5 # 期待値 valueAIN1BwExpctd = 0 # low valueAIN2BwExpctd = 1 # high valueAIN1NuExpctd = 0 # low valueAIN2NuExpctd = 0 # low # ターゲット生成 motor = Motor(PIN_AIN1, PIN_AIN2, pwm=False) ain1_pin = Device.pin_factory.pin(PIN_AIN1) ain2_pin = Device.pin_factory.pin(PIN_AIN2) # 実際値 motor.backward() sleep(0.1) valueAIN1Actual = ain1_pin.state valueAIN2Actual = ain2_pin.state try: # 評価 self.assertEqual(valueAIN1Actual, valueAIN1BwExpctd) self.assertEqual(valueAIN2Actual, valueAIN2BwExpctd) # 実際値 motor.stop() sleep(0.1) valueAIN1Actual = ain1_pin.state valueAIN2Actual = ain2_pin.state # 評価 self.assertEqual(valueAIN1Actual, valueAIN1NuExpctd) self.assertEqual(valueAIN2Actual, valueAIN2NuExpctd) sleep(0.1) finally: # 終了 motor.close()
def main(): # 初期化 factory = PiGPIOFactory() motor_left = Motor(forward=dcm_pins["left_forward"], backward=dcm_pins["left_backward"], pin_factory=factory) motor_right = Motor(forward=dcm_pins["right_forward"], backward=dcm_pins["right_backward"], pin_factory=factory) # 前進 -> 停止 -> 後進 -> 停止 try: # 前進 - 1秒 print("前進 - 1秒") motor_left.forward() motor_right.forward() sleep(1) # 停止 - 1秒 print("停止 - 1秒") motor_left.stop() motor_right.stop() sleep(1) # 後進 - 1秒 print("後進 - 1秒") motor_left.backward() motor_right.backward() sleep(1) # 停止 print("停止") motor_left.stop() motor_right.stop() except KeyboardInterrupt: print("stop") # 停止 motor_left.stop() motor_right.stop() return
class DriveMotor: myMotor = 0 pin1 = 0 pin2 = 0 currentPower = 0 # requires the two gpio pins def __init__(self, pin1, pin2): self.pin1 = pin1 self.pin2 = pin2 self.myMotor = Motor(pin1, pin2) # Use this to change the motor power def setPower(self, power): self.currentPower = power if power > 0: self.myMotor.forward(power) else: self.myMotor.backward(-power) # get's the current power of the motor def getPower(self): return self.currentPower
class Remote_GPIO: def __init__(self): self.run = True self.rem_pi = PiGPIOFactory() self.motor_left = Motor(20, 21) self.motor_right = Motor(19, 26) def remote_gpio_init(self): print("connected to pi") while self.run: print("testing forward") self.motor_left.forward() self.motor_right.forward() sleep(2) self.motor_right.stop() self.motor_left.stop() print("testing backward") self.motor_left.backward() self.motor_right.backward() sleep(2) self.motor_right.stop() self.motor_left.stop() print("testing left") self.motor_left.forward() sleep(2) self.motor_left.stop() print("testing right") self.motor_right.forward() sleep(2) self.motor_right.stop() print("finished tests") self.motor_left.stop() self.motor_right.stop() self.close_connection() def close_connection(self): self.run = False
class MotorCtrlService(object): """FB Service""" def __init__(self, topic, event_emitter=EventEmitter()): logging.debug("initializing motor control!") event_emitter.on(topic, self.act) self.motor_right = Motor(17, 18) self.motor_left = Motor(6, 12) self.start() def start(self): self.full_spin() def full_spin(self): logging.debug("full spin maneuver!") self.stop() self.motor_left.forward(1) self.motor_right.backward(1) time.sleep(2) self.stop() def forward(self, speed=1): self.move() def backward(self, speed=1): self.move(-1, -1) def move(self, speed_right=1, speed_left=1): logging.debug( "Moving motor: %(speed_right)s | %(speed_left)s" % locals()) self.stop() if speed_right > 0: self.motor_right.forward(speed_right) pass elif speed_right < 0: self.motor_right.backward(math.fabs(speed_right)) else: self.motor_right.stop() if speed_left > 0: self.motor_left.forward(speed_left) elif speed_left < 0: self.motor_left.backward(math.fabs(speed_left)) else: self.motor_left.stop() def stop(self): self.motor_right.stop() self.motor_left.stop() def act(self, msg): """perform motor move""" logging.debug("acting !!! -> " + str(msg) + " left:" + str(msg["speed_left"])) self.move( speed_left=float(msg["speed_left"]), speed_right=float(msg["speed_right"]))
class Autobot(object): def __init__(self, left=None, right=None): self.left_motor = Motor(*left) self.right_motor = Motor(*right) def forward(self, speed=0.52): self.left_motor.forward(speed) self.right_motor.forward(speed) def backwards(self, speed=0.52): self.left_motor.backward(speed) self.right_motor.backward(speed) def left(self, speed=0.55): self.right_motor.forward(0.15) self.left_motor.forward(speed) def right(self, speed=0.55): self.right_motor.forward(speed) self.left_motor.forward(0.15) def stop(self): self.left_motor.stop() self.right_motor.stop()
class GamePad: """ゲームパッドに割り振る操作を入れるクラス""" def __init__(self) -> None: self.front_motor = Motor(11, 12) self.right_motor = Motor(13, 15) self.left_motor = Motor(16, 18) def fork_lift_up(self, analog_input: float) -> None: """ (アナログ入力)フォークリフトを入力した速度で上昇させる Args: analog_input(float): ゲームパッドのアナログ入力値 """ self.front_motor.forward(analog_input) def fork_lift_down(self, analog_input: float) -> None: """ (アナログ入力)フォークリフトを入力した速度で下降させる Args: analog_input(float): ゲームパッドのアナログ入力値 """ self.front_motor.backward(-analog_input) def axis_vertical_right(self, stick_input: float, margin: float) -> None: """ (スティック入力)入力した速度で右モータでの前後移動 アナログスティックは完全な (0, 0) 座標を返さないので入力にマージンを持たせる Args: stick_input(float): ゲームスティックのアナログ入力値 (-1.0 ~ 1.0) margin(float): 入力を無視する閾値 """ if stick_input > margin: self.right_motor.forward(stick_input) elif stick_input < -margin: self.right_motor.backward(-stick_input) else: self.right_motor.stop() def axis_vertical_left(self, stick_input: float, margin: float) -> None: """ (スティック入力)入力した速度で左モータでの前後移動 アナログスティックは完全な (0, 0) 座標を返さないので入力にマージンを持たせる Args: stick_input(float): ゲームスティックのアナログ入力値 (-1.0 ~ 1.0) margin(float): 入力を無視する閾値 """ if stick_input > margin: self.left_motor.forward(stick_input) elif stick_input < -margin: self.left_motor.backward(-stick_input) else: self.left_motor.stop()
class RaspberryRobot(object): def __init__(self): self.front_left_motor = Motor(7, 8) self.front_right_motor = Motor(10, 9) self.rear_left_motor = Motor(6, 13) self.rear_right_motor = Motor(26, 19) def stop(self): print("stop") self.front_left_motor.stop() self.front_right_motor.stop() self.rear_left_motor.stop() self.rear_right_motor.stop() def forward(self): print("go forward") self.front_left_motor.forward() self.front_right_motor.forward() self.rear_left_motor.forward() self.rear_right_motor.forward() def backward(self): print("go backward") self.front_left_motor.backward() self.front_right_motor.backward() self.rear_left_motor.backward() self.rear_right_motor.backward() def left(self): print("left") self.front_left_motor.forward(0) self.front_right_motor.forward() self.rear_left_motor.forward(0) self.rear_right_motor.forward() def right(self): print("right") self.front_left_motor.forward() self.front_right_motor.forward(0) self.rear_left_motor.forward() self.rear_right_motor.forward(0)
class Car(): def __init__(self): self.motorright = Motor(24, 27) self.motorright_enable = OutputDevice(5, initial_value=1) self.motorleft = Motor(6, 22) self.motorleft_enable = OutputDevice(17, initial_value=1) def forward(self): self.motorleft.backward() self.motorright.backward() def backward(self): self.motorleft.forward() self.motorright.forward() def left(self): self.motorleft.forward() self.motorright.backward() def right(self): self.motorleft.backward() self.motorright.forward() def stop(self): self.motorleft.stop() self.motorright.stop() def test(self): self.forward() sleep(1) self.backward() sleep(1) self.left() sleep(1) self.right() sleep(1) self.stop()
class CarMotorHJduino(): def __init__(self): self.motor_lx = Motor(18, 24) self.motor_rx = Motor(23, 25) def forward(self): self.motor_rx.forward() self.motor_lx.forward() def backward(self): self.motor_rx.backward() self.motor_lx.backward() def stop(self): self.motor_rx.stop() self.motor_lx.stop() def right(self): self.motor_lx.forward() self.motor_rx.backward() def left(self): self.motor_rx.forward() self.motor_lx.backward()
class Car: def __init__(self, devices=devices): self._speed = .5 self._turn = .5 if devices: self.devices = devices self.connect(devices) def connect(self, devices): self.front = Motor(*devices['front']) self.back = Motor(*devices['back']) self.steer = Motor(*devices['turn']) def forward(self): self.front.forward(self._speed) self.back.forward(self._speed) def reverse(self): self.front.backward(self._speed) self.back.backward(self._speed) def stop(self): self.front.stop() self.back.stop() self.steer.stop() def turn_right(self): self.steer.forward(self._turn) def turn_left(self): self.steer.backward(self._turn) def straight(self): self.steer.stop() def speed(self, value): if 0 <= value and value <= 1: self._speed = value def turn_speed(self, value): if 0 <= value and value <= 1: self._turn = value
#print(data) #print(type(data)) data = data.decode("utf-8") #ldr = LightSensor(26) if data == cccmd[0]: #time.sleep(1) a.forward(0.5) time.sleep(0.8) a.stop() print('Curtain ON') if data == cccmd[1]: #time.sleep(1) a.backward(0.3) time.sleep(0.8) a.stop() print('Curtain OFF') if data == cccmd[2]: flag4 = 0 #flag=0 if not data: print('hello') break if flag4 == 0: break except Exception as msg: logging.exception(msg)
from gpiozero import Motor import time Fright=Motor(9,10) Fleft=Motor(22,27) Bright=Motor(3,2) for i in range(0,4): Fright.forward() Fleft.forward() Bleft.forward() Bright.forward() time.sleep(5) Fright.stop() Bleft.stop() Fleft.stop() Bright.stop() Fright.forward() #acually fleft Bright.backward() Fleft.backward() #actually fright Bleft.forward() time.sleep(0.9) Fright.stop() Bleft.stop() Fleft.stop() Bright.stop()
backward() left_turn() backward() # if __name__ == '__main__': cmd='' while cmd is not 'e': cmd=raw_input('Cmd:') if cmd=='w': print "forword 2 sec" motor2.forward() # full speed forwards motor3.forward() # full speed forwards sleep(2) elif cmd=='s': print "backword 2 sec" motor2.backward() # full speed backwards motor3.backward() # full speed backwards sleep(2) elif cmd=='a': print "left turn" left_turn() elif cmd=='d': print "right turn" right_turn() elif cmd=='8': print "run 8" eight() elif cmd=='e': break motor2.stop() motor3.stop()
from gpiozero import Motor from time import sleep motor1 = Motor(23, 24) print("Motor 1 forward") motor1.forward() sleep(2) print("Motor 1 backward") motor1.backward() sleep(2) print("Motor 1 forward slow") motor1.forward(0.20) sleep(2) print("Motor 1 backward slow") motor1.backward(0.20) sleep(2) print("Motor 1 stop") motor1.stop() motor2 = Motor(20, 21) print("Motor 2 forward") motor2.forward() sleep(2) print("Motor 2 backward") motor2.backward() sleep(2) print("Motor 2 forward slow") motor2.forward(0.20) sleep(2) print("Motor 2 backward slow") motor2.backward(0.20)
while True: print "Left motor forward" motorl.forward(1) time.sleep(0.5) motorl.forward(0) time.sleep(2) print "Right motor forward" motorr.forward(1) time.sleep(0.5) motorr.forward(0) time.sleep(2) print "Left motor backwards" motorl.backward(1) time.sleep(0.5) motorl.backward(0) time.sleep(2) print "Right motor backwards" motorr.backward(1) time.sleep(0.5) motorr.backward(0) time.sleep(2) print "Forward" motorl.forward(1) motorr.forward(1) time.sleep(0.5) motorl.forward(0)
from gpiozero import Motor from time import sleep m1 = Motor(14,15) speed = 0.5 m1.forward(speed) sleep(1) m1.stop() speed = 1 m1.backward(speed) sleep(1) m1.stop()
def sstop(): ml.stop() mr.stop() except KeyboardInterrupt: print "cleaning" finally: #GPIO.cleanup() print"check it" while(True): print "Entering" if (raw_input()=='w'): print "forward" forward() elif raw_input()=='s': print "backward" backward() elif raw_input()=='a': print "left" ml.backward(0.5) mr.forward(0.5) elif raw_input()=='d': print "right" mr.backward(0.5) ml.forward(0.5) else: sstop() print "stopped"
from gpiozero import Motor from time import sleep import Rpi.GPIO as GPIO motor = Motor(forward=26, backward=20) counter = 0 try: while counter < 10: motor.forward() sleep(5) motor.backward() sleep(5) counter +=1 finally: GPIO.cleanup()