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 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 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 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 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 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 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 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()
def main():
motor = Motor(26, 20)
button = Button(6)
button.when_pressed = callback_rpm
for _ in range(3):
speed = float(input('speed: '))
motor.forward(speed)
for _ in range(61):
print(rpm())
time.sleep(1)
motor.stop()
class Pump_Control:
def __init__(self):
self.pump = Motor(17, 18)
self.State = False
def start_pump(self):
self.State = True
self.pump.forward()
def stop_pump(self):
self.State = False
self.pump.stop()
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 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 Car:
def __init__(self, speed: float = 1):
self.speed = speed
self.diff = 0.04
self.forward_right_motor = Motor(forward=12, backward=16)
self.backward_right_motor = Motor(forward=21, backward=20)
self.forward_left_motor = Motor(forward=23, backward=18)
self.backward_left_motor = Motor(forward=24, backward=25)
self.sensor = DistanceSensor(13, 6)
def stop(self):
self.forward_left_motor.stop()
self.forward_right_motor.stop()
self.backward_left_motor.stop()
self.backward_right_motor.stop()
def not_in_safe_distance(self, distance_threshold=SAFE_DISTANCE_THRESHOLD):
distance = round(self.sensor.distance * 100, 4)
return distance > distance_threshold
def forward(self, speed: float = None):
speed = max(min(speed if speed else self.speed, 1), 0)
right_speed = max(0.0, speed - self.diff)
self.forward_left_motor.forward(speed=speed)
self.forward_right_motor.forward(speed=right_speed)
self.backward_left_motor.forward(speed=speed)
self.backward_right_motor.forward(speed=right_speed)
def backward(self, speed: float = None):
speed = max(min(speed if speed else self.speed, 1), 0)
right_speed = max(0.0, speed - self.diff)
self.forward_left_motor.backward(speed=speed)
self.forward_right_motor.backward(speed=right_speed)
self.backward_left_motor.backward(speed=speed)
self.backward_right_motor.backward(speed=right_speed)
def left(self, speed: float = None):
speed = max(min(speed if speed else self.speed, 1), 0)
right_speed = max(0.0, speed - self.diff)
self.forward_left_motor.backward(speed=speed)
self.forward_right_motor.forward(speed=right_speed)
self.backward_left_motor.backward(speed=speed)
self.backward_right_motor.forward(speed=right_speed)
def right(self, speed: float = None):
speed = max(min(speed if speed else self.speed, 1), 0)
right_speed = max(0.0, speed - self.diff)
self.forward_left_motor.forward(speed=speed)
self.forward_right_motor.backward(speed=right_speed)
self.backward_left_motor.forward(speed=speed)
self.backward_right_motor.backward(speed=right_speed)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model_name',
default='test_model',
help='Model identifier.')
parser.add_argument('--model_path',
required=True,
help='Path to model file.')
parser.add_argument('--speed',
default=0.5,
type=float,
help='Reduction factor on speed')
args = parser.parse_args()
model = ModelDescriptor(name=args.model_name,
input_shape=(1, 192, 192, 3),
input_normalizer=(0, 1),
compute_graph=utils.load_compute_graph(
args.model_path))
left = Motor(PIN_A, PIN_B)
right = Motor(PIN_C, PIN_D)
print('spinning')
try:
with PiCamera(sensor_mode=4, framerate=30):
with CameraInference(model) as inference:
for result in inference.run():
data = [
tensor.data for _, tensor in result.tensors.items()
]
lspeed, rspeed = data[0]
print('#%05d (%5.2f fps): %1.2f/%1.2f' %
(inference.count, inference.rate, lspeed, rspeed))
if lspeed < 0:
left.reverse(-max(-1, lspeed) * args.speed)
else:
left.forward(min(1, lspeed) * args.speed)
if rspeed < 0:
right.reverse(-max(-1, rspeed) * args.speed)
else:
right.forward(min(1, rspeed) * args.speed)
except Exception as e:
left.stop()
right.stop()
print(e)
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 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
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()
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 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 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, front_left_pins, front_right_pins, back_left_pins,
back_right_pins):
self.direction = None
self.front_left = Motor(front_left_pins[0], front_left_pins[1])
self.front_right = Motor(front_right_pins[0], front_right_pins[1])
self.back_left = Motor(back_left_pins[0], back_left_pins[1])
self.back_right = Motor(back_right_pins[0], back_right_pins[1])
def go_forward(self):
print("go forward")
self.front_left.forward()
self.front_right.forward()
self.back_left.forward()
self.back_right.forward()
def go_backward(self):
print("go backward")
self.front_left.backward()
self.front_right.backward()
self.back_left.backward()
self.back_right.backward()
def stop(self):
print("stop")
self.front_left.stop()
self.front_right.stop()
self.back_left.stop()
self.back_right.stop()
def turn_left(self):
print("turn left")
self.front_left.backward()
self.front_right.forward()
self.back_left.backward()
self.back_right.forward()
def turn_right(self):
print("turn right")
self.front_left.forward()
self.front_right.backward()
self.back_left.forward()
self.back_right.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
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)
tcpCliSock, addr = tcpSerSock.accept()
print("...connected from : ", addr)
try:
while True:
data = tcpCliSock.recv(BUFSIZE)
#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')
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
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()
class RoPiMotor:
# initialize
def __init__(self, remote_address):
# set PINs on BOARD
log.debug("Initializing Motors...")
log.debug("> back left PIN: " + str(_conf['motor_back_left_pin']))
log.debug("> back right PIN: " + str(_conf['motor_back_right_pin']))
log.debug("> front left PIN: " + str(_conf['motor_front_left_pin']))
log.debug("> front right PIN: " + str(_conf['motor_front_right_pin']))
# using Motor
rem_pi = PiGPIOFactory(host=remote_address)
self.motor1 = Motor(_conf['motor_front_left_pin'],
_conf['motor_back_left_pin'],
pin_factory=rem_pi)
self.motor2 = Motor(_conf['motor_front_right_pin'],
_conf['motor_back_right_pin'],
pin_factory=rem_pi)
# directions
self.motor1_direction = Value("i", 0)
self.motor2_direction = Value("i", 0)
# queues and processes
log.debug("Initializing Motors queues and processes...")
self.queue1 = Queue()
self.queue2 = Queue()
self.process1 = Process(target=self.M1)
self.process2 = Process(target=self.M2)
self.process1.start()
self.process2.start()
log.debug("...init done!")
# clean a queue
def clearQueue(self, q):
while not q.empty():
q.get()
# clean all queues
def cleanQueues(self):
log.debug("Cleaning queues...")
self.clearQueue(self.queue1)
self.clearQueue(self.queue2)
# stop the motors
def stop(self):
self.cleanQueues()
self.motor1.stop()
self.motor2.stop()
# control motor process 1
def M1(self):
self.worker(self.motor1, self.queue1)
# control motor process 2
def M2(self):
self.worker(self.motor2, self.queue2)
# worker
def worker(self, motor, queue):
try:
while True:
if not queue.empty():
direction = queue.get().split("|")
acceleration = float(direction[2])
speed = float(direction[1])
direction = direction[0]
log.debug("Going direction [" + str(direction) + "] at [" +
str(speed) + "] speed for " + str(acceleration) +
"s")
if direction == "f":
motor.forward(speed=speed)
elif direction == "b":
motor.backward(speed=speed)
sleep(acceleration)
motor.stop()
except KeyboardInterrupt:
pass
# go forward
def forward(self, speed=1, duration=_conf['ACCELERATION_TIME']):
if not self.motor1_direction.value == 1:
self.clearQueue(self.queue1)
self.motor1_direction.value = 1
if not self.motor2_direction.value == 1:
self.clearQueue(self.queue2)
self.motor2_direction.value = 1
self.queue1.put("f|" + str(speed) + "|" + str(duration))
self.queue2.put("f|" + str(speed) + "|" + str(duration))
# go backward
def backward(self, speed=1, duration=_conf['ACCELERATION_TIME']):
if not self.motor1_direction.value == -1:
self.clearQueue(self.queue1)
self.motor1_direction.value = -1
if not self.motor2_direction.value == -1:
self.clearQueue(self.queue2)
self.motor2_direction.value = -1
self.queue1.put("b|" + str(speed) + "|" + str(duration))
self.queue2.put("b|" + str(speed) + "|" + str(duration))
# go forward LEFT
def forwardleft(self, speed=1, duration=_conf['ACCELERATION_TIME']):
self.clearQueue(self.queue2)
if not self.motor1_direction.value == 1:
self.clearQueue(self.queue1)
self.motor1_direction.value = 1
self.queue1.put("f|" + str(speed) + "|" + str(duration))
# go forward RIGHT
def forwardright(self, speed=1, duration=_conf['ACCELERATION_TIME']):
self.clearQueue(self.queue1)
if not self.motor2_direction == 1:
self.clearQueue(self.queue2)
self.motor2_direction.value = 1
self.queue2.put("f|" + str(speed) + "|" + str(duration))
# go backward LEFT
def backwardleft(self, speed=1, duration=_conf['ACCELERATION_TIME']):
self.clearQueue(self.queue2)
if not self.motor1_direction.value == -1:
self.clearQueue(self.queue1)
self.motor1_direction.value = -1
self.queue1.put("b|" + str(speed) + "|" + str(duration))
# go backward RIGHT
def backwardright(self, speed=1, duration=_conf['ACCELERATION_TIME']):
self.clearQueue(self.queue1)
if not self.motor2_direction.value == -1:
self.clearQueue(self.queue2)
self.motor2_direction.value = -1
self.queue2.put("b|" + str(speed) + "|" + str(duration))
# terminate
def terminate(self):
log.debug("Motors termination...")
self.process1.terminate()
self.process2.terminate()
self.stop()
self.queue1.close()
self.queue1.join_thread()
self.queue2.close()
self.queue2.join_thread()
self.motor1.close()
self.motor2.close()
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)
sleep(2)
print("Motor 2 stop")
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()
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
import explorerhat
from gpiozero import Button, LED, Motor
from time import sleep
button = Button(9)
led1 = LED(10)
motor1 = Motor(forward=19 , backward=20)
motor2 = Motor(forward=21 , backward=26)
while True:
if button.is_pressed:
print("Button pressed")
led1.on()
motor1.forward()
motor2.forward()
else:
print("Button is not pressed")
led1.off()
motor1.stop()
motor2.stop()
from gpiozero import Motor
import time
#from gpiozero.Pin import
#import RPi.GPIO as GPIO
mr = Motor(3, 2)
ml = Motor(15, 14)
ml.stop()
mr.stop()
try:
def forward():
ml.forward(0.3)
mr.forward(0.3)
def backward():
ml.backward(0.3)
mr.backward(0.3)
def sstop():
ml.stop()
mr.stop()
while(True):
while(raw_input()=='w'):
print "forward"
forward()
time.sleep(1)
while(raw_input()=='s'):
