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()
