Exemplo n.º 1
0
import RPi.GPIO as GPIO
import time
import sys
from gpiozero import Motor

GPIO.setmode(GPIO.BCM)

### Setup Motor Control ###
leftPos = 3
leftNeg = 2
rightPos = 17
rightNeg = 4

motorLeft = Motor(leftPos, leftNeg);
motorRight = Motor(rightPos, rightNeg);
motorLeft.stop();
motorRight.stop();


sensorForHardRight = [1, 1, 1, 0, 0, 0];
sensorForCurveRight = [0, 1, 1, 0, 0, 0];
sensorForRight = [1, 0, 0, 0, 0, 0];
sensorForRight1 = [0, 1, 0, 0, 0, 0];
sensorForHardLeft = [0, 0, 1, 0, 1, 1];
sensorForCurveLeft = [0, 0, 1, 0, 1, 0];
sensorForLeft = [0, 0, 0, 0, 1, 0];
sensorForLeft1 = [0, 0, 0, 0, 0, 1];
sensorForStraight1 = [0, 0, 1, 1, 0, 0];
sensorForStraight2 = [0, 0, 0, 1, 0, 0];
sensorForStraight3 = [0, 0, 1, 0, 0, 0];
sensorForStop = [0, 0, 0, 0, 0, 0];
Exemplo n.º 2
0
# import curses
from gpiozero import Motor, Servo
from time import sleep
xMotor = Motor(forward=7, backward=0)
# yMotor = Motor(forward=2, backward=3)
# triggerServo = Servo(1)

while True:
    xMotor.forward()
    sleep(5)
    xMotor.backward()
    sleep(5)
Exemplo n.º 3
0
from gpiozero import Robot, Motor, DistanceSensor
from signal import pause

sensor = DistanceSensor(23, 24, max_distance=1, threshold_distance=0.2)
robot = Robot(left=Motor(4, 14), right=Motor(17, 18))

sensor.when_in_range = robot.backward
sensor.when_out_of_range = robot.stop
pause()
Exemplo n.º 4
0
from gpiozero import Motor

pump = Motor(17, 18)
pump.stop()
Exemplo n.º 5
0
class Py_Driver():  #Node):
    def __init__(self, **kwargs):
        #super().__init__('py_driver')
        #self.subscription = self.create_subscription(Twist,'cmd_vel',self.listener_callback,0) # Store 10 messages, drop the oldest one
        #self.subscription  # prevent unused variable warning
        self.kwargs = kwargs
        # print(self.kwargs)

        self._left_pwm = PWMOutputDevice(kwargs['left_pin'],
                                         kwargs['left_active_high'])
        self._left_motor = Motor(kwargs['left_forward'],
                                 kwargs['left_backward'], kwargs['left_pwm'])
        self._right_pwm = PWMOutputDevice(kwargs['right_pin'],
                                          kwargs['right_active_high'])
        self._right_motor = Motor(kwargs['right_forward'],
                                  kwargs['right_backward'],
                                  kwargs['right_pwm'])
        print("Py Pi driver initialiased")

    def listener_callback(self, msg):
        # self.get_logger().info('Setting left & right wheel speed: %d %d' % (msg.linear.x, msg.angular.z))
        _move_dict = {'linear': msg.linear.x, 'angular': msg.angular.z}
        self.move = _move_dict

    def test_motors(self):
        # for i in range(0,6,1):
        # i=(i+5)/10
        # print(i)
        i = 0.6

        self._left_pwm.value = i
        self._left_motor.forward()
        self._right_pwm.value = i
        self._right_motor.forward()
        time.sleep(1.0)
        self._left_motor.stop()
        self._right_motor.stop()

    # Code relevant for tuning the left and right wheel movement
    @property
    def move(self):  #, linear_speed, angular_speed): # Use cmd_vel
        print("Getting movement")
        return self._move
        # Check that movement is consistent for both wheels, maybe with a scalar in the PWM.

    @move.setter
    def move(self,
             _move_dict):  # Speed is with respect to the front of the car
        if (abs(_move_dict['linear']) > 0.5):
            _move_dict['linear'] = np.sign(_move_dict['linear']) * 0.5
            print("Movement constrained")
        if (abs(_move_dict['angular']) > 1.0):
            _move_dict['angular'] = np.sign(_move_dict['angular']) * 1.0
            print("Movement constrained")

        if (abs(_move_dict['linear']) <= 0.5 and _move_dict['angular'] == 0.0):
            print("Change")
            self._left_pwm.value = abs(_move_dict['linear'] / 0.5)
            self._right_pwm.value = abs(_move_dict['linear'] / 0.5)
            if np.sign(_move_dict['linear']) == 1:
                self._left_motor.forward()
                self._right_motor.forward()
            elif np.sign(_move_dict['linear']) == -1:
                self._left_motor.backward()
                self._right_motor.backward()
                print("Acts")
            print("Linear movement")

        elif (abs(_move_dict['linear']) == 0.0
              and abs(_move_dict['angular']) >= 1.0):
            self._left_pwm.value = abs(_move_dict['angular'] / 1.0)
            self._right_pwm.value = abs(_move_dict['angular'] / 1.0)
            if np.sign(_move_dict['angular']) == 1:
                self._left_motor.backward()
                self._right_motor.forward()
                print("Left wheel back, right wheel front")
            elif np.sign(_move_dict['angular']) == -1:
                self._left_motor.forward()
                self._right_motor.backward()
                print("Right wheel back, left wheel front")
            print("This bucket", (np.sign(_move_dict['angular']) == False))

        elif (abs(_move_dict['linear']) >= 0.5
              and abs(_move_dict['angular']) >= 1.0):
            if (np.sign(_move_dict['angular']) == 1
                    and np.sign(_move_dict['linear']) == 1):
                self._left_pwm.value = 0.5
                self._right_pwm.value = 1.0
                self._left_motor.forward()
                self._right_motor.forward()
            elif (np.sign(_move_dict['angular']) == -1
                  and np.sign(_move_dict['linear']) == 1):
                self._left_pwm.value = 1.0
                self._right_pwm.value = 0.5
                self._left_motor.forward()
                self._right_motor.forward()
            if (np.sign(_move_dict['angular']) == 1
                    and np.sign(_move_dict['linear']) == -1):
                self._left_pwm.value = 1.0
                self._right_pwm.value = 0.5
                self._left_motor.backward()
                self._right_motor.backward()
            elif (np.sign(_move_dict['angular']) == -1
                  and np.sign(_move_dict['linear']) == -1):
                self._left_pwm.value = 0.5
                self._right_pwm.value = 1.0
                self._left_motor.backward()
                self._right_motor.backward()

            print("Last bucket")

        else:
            self._left_pwm.value = abs(
                (_move_dict['linear'] / 0.5 - _move_dict['angular'] / 1.0) /
                2.0)
            self._right_pwm.value = abs(
                (_move_dict['linear'] / 0.5 + _move_dict['angular'] / 1.0) /
                2.0)
            if (np.sign(_move_dict['linear']) == 1):
                self._left_motor.forward()
                self._right_motor.forward()
            elif (np.sign(_move_dict['linear']) == -1):
                self._left_motor.forward()
                self._right_motor.backward()
            print("Really the last bucket now")

        time.sleep(0.1)
        self._left_motor.stop()
        self._right_motor.stop()
Exemplo n.º 6
0
from gpiozero import Motor
import time
motor1 = Motor(9,10)
motor2 = Motor(7,8)

while True:
    
    for i in range(2):
        motor1.backward(speed=0.3)
        motor2.forward(speed=0.9)
        time.sleep(1)
    for i in range(2):
        motor1.backward(speed=1)
        motor2.forward(speed=0.2)
        time.sleep(1)    
    motor1.stop()
    motor2.stop()
    time.sleep(1)
Exemplo n.º 7
0
import paho.mqtt.client as mqtt
import encoder_pid as epid

from gpiozero import Motor

import threading
import time
# import ultrasonic as us
import math
# motl = Motor(2, 3)
# motr= Motor(14, 15)
motl = Motor(3, 2)
motr = Motor(15, 14)

lr_pos_r = 0
fwrev_pos_r = 0


def on_connect(client, userdata, flags, rc):
    print("Connected with result code " + str(rc))

    client.subscribe('joystick/lr')
    client.subscribe('joystick/fwrev')
    client.subscribe('joystick/accl')

    client.subscribe('joystick/cam_rst')
    client.subscribe('joystick/cam_up_down')


def on_message(client, userdata, msg):
    global lr_pos_r, fwrev_pos_r, accl_val
Exemplo n.º 8
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()
Exemplo n.º 9
0
label_wiimote_buttons = "Nintendo Wii Remote"
label_wiimote_accel = "Nintendo Wii Remote Accelerometer"


# Button ID's
buttonId = [103, 108, 105, 106, 304, 305, 407, 412, 316, 257, 258]
# Button Held States
buttonHeld = [False, False, False, False, False, False, False, False, False, False, False]

# Indexes for both arrays:
#  0   1   2     3    4   5   6     7     8   9   10
# UP DOWN LEFT RIGHT (A) (B) PLUS MINUS HOME (1) (2)


# Motors
leftWheels = Motor(16, 13)
rightWheels = Motor(6, 5)
lowerArm = Motor(10, 25)
upperArm = Motor(26, 21)
clawExtend = Motor(3, 4)
clawClose = Motor(17, 22)

# Inhibits
leftWheelsInh = LED(19) # note: I know this isn't an LED: the LED module simply works really easily
rightWheelsInh = LED(12)
lowerArmInh = LED(11)
upperArmInh = LED(20)
clawExtendInh = LED(2)
clawCloseInh = LED(27)

# Nerf gun
Exemplo n.º 10
0
import paho.mqtt.client as mqtt
from gpiozero import Motor
import threading
import time
import ultrasonic as us
# motl = Motor(2, 3)
# motr= Motor(14, 15)
motl = Motor(3, 2)
motr = Motor(15, 14)

joys_pos = []
lr_pos_r = 0
fwrev_pos_r = 0

l_stop_val = 0
r_stop_val = 0


def on_connect(client, userdata, flags, rc):
    print("Connected with result code " + str(rc))

    client.subscribe('joystick/lr')
    client.subscribe('joystick/fwrev')


def on_message(client, userdata, msg):
    global joys_pos, lr_pos_r, fwrev_pos_r

    if msg.topic == 'joystick/fwrev':
        fwrev_pos_r = float(msg.payload.decode())
Exemplo n.º 11
0
# -*- coding: utf-8 -*-
"""
Created on Sat Aug 29 22:54:52 2020

@author: Ryan
"""

from gpiozero import DistanceSensor as ds
from gpiozero import Motor
import time 
senFor = ds(31,32, max_distance = 1, threshold_distance = .15)
senLeft= ds(33,34,max_distance = 1, threshold_distance = .15)
senRight= ds(35,36,max_distance = 1, threshold_distance = .15)
sen4Back= ds(37,38,max_distance = 1, threshold_distance = .15)
motor1 = Motor(17,18)#left
motor2 = Motor(19,20)#right



def OnRoadAgain:
    motor1.forward(.2)
    motor2.forward(.2)



def forwardOBPlan():
     motor1.forward(0)
     motor2.forward(0)
     time.sleep(1)
     motor1.backward(.1)
     motor2.backward(.1)
Exemplo n.º 12
0
from gpiozero import Motor
from time import sleep

mt = Motor(19, 13)

mt.forward(0.5)
sleep(3)
mt.stop()
sleep(1)
mt.backward(0.5)
sleep(3)
mt.stop()
Exemplo n.º 13
0
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()
Exemplo n.º 14
0
# Starts a motor with Motor class

from gpiozero import Motor
from time import sleep

motor = Motor(forward=4, backward=14)

while True:
    motor.forward()
    sleep(5)
    motor.backward()
    sleep(5)
    motor.stop()
Exemplo n.º 15
0
from gpiozero import Motor, AngularServo

#then import the 'sleep' class from the 'time' library (so we can add pauses in our program)
from time import sleep

gun_motor = Motor(13, 19)
laser = Motor(5, 6)
servo = AngularServo(26, min_angle=-40, max_angle=50)
retract = -40
fire = 50

print('laser on')
laser.forward()

print('servo back')
servo.angle = retract
sleep(0.5)
print('motors on')
gun_motor.forward(1)
sleep(5)

for x in range(5):
    print('fire ', x + 1)
    servo.angle = fire
    sleep(0.5)
    print('retract')
    servo.angle = retract
    sleep(3)

gun_motor.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'):
Exemplo n.º 17
0
def joystick_loop(j, ):
    robot = Robot((27, 4), (6, 5))
    fork = Motor(15, 23)
    lift = Motor(20, 21)
    print('Pins OK')
    try:
        axes = {}
        d_pad = '(0, 0) '
        buttons = []
        acceleration_mode = False
        stick_mode = False
        forward = False
        d_pad_x, d_pad_y = 0, 0
        nom_left, nom_right = 0, 0
        while True:
            try:
                events = pygame.event.get()
                for event in events:
                    if event.type == pygame.JOYBUTTONDOWN:
                        buttons.append(str(event.button))
                        if event.button == 1:
                            # switch soft acceleration mode
                            acceleration_mode = not acceleration_mode
                        elif event.button == 2:
                            try:
                                # blocking scan function
                                scan()
                                try:
                                    buttons.remove(str(event.button))
                                except ValueError:
                                    pass
                            except Exception as e:
                                print(f'\r{e}')
                        elif event.button == 3:
                            # switch control map
                            stick_mode = not stick_mode
                    elif event.type == pygame.JOYBUTTONUP:
                        try:
                            buttons.remove(str(event.button))
                        except ValueError:
                            pass
                    elif event.type == pygame.JOYAXISMOTION:
                        if abs(event.value) > 0.1:
                            axes[event.axis] = f'{event.value:+.4f}'
                        else:
                            axes[event.axis] = f'{0.0:+.4f}'
                    elif event.type == pygame.MOUSEMOTION:
                        pass  # print(event.rel, event.buttons)
                    elif event.type == pygame.MOUSEBUTTONDOWN:
                        pass
                    elif event.type == pygame.MOUSEBUTTONUP:
                        pass
                    elif event.type == pygame.JOYHATMOTION:
                        d_pad = f'{event.value} '
                        d_pad_x, d_pad_y = event.value
                    else:
                        print(event)

                    # logging and writing to motors
                    buttons.sort(key=lambda x: int(x))
                    ax = list(axes.items())
                    ax.sort(key=lambda x: x[0])
                    left, right = -float(axes.get(1, '+0.0')), -float(
                        axes.get(4, '+0.0'))
                    if stick_mode:
                        left, right = joy_to_motor_best(
                            -float(axes.get(0, '+0.0')),
                            -float(axes.get(1, '+0.0')))
                    if acceleration_mode:
                        left, right, nom_left, nom_right = calculate_diff(
                            left, right, nom_left, nom_right, diff=0.005)
                    if forward:
                        left, right = 0.1, 0.1
                    print('\rButtons: ' + d_pad + ' '.join(buttons) +
                          ' Axes: ' + '; '.join([f'{k}: {v}' for k, v in ax]),
                          end=f'     ({left}, {right})')
                    robot.value = (left, right)
                    lift.value = -d_pad_y
                    fork.value = -d_pad_x

            except Exception as e:
                print(f'\r{e}')

    except KeyboardInterrupt:
        print("\rEXITING NOW")
        j.quit()
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.6)
        mr.forward(0.6)

    def backward():
        ml.backward(0.7)
        mr.backward(0.7)

    
        
    def sstop():
        ml.stop()
        mr.stop()
except KeyboardInterrupt:
    print "cleaning"
finally:
    #GPIO.cleanup()
    print"check it"
Exemplo n.º 19
0
			self.old_btn_state[new_abbv] = 0
		elif event.ev_type == 'Absolute':
			new_abbv = 'A' + str(self._other)
			self.abs_state[new_abbv] = 0
			self.old_abs_state[new_abbv] = 0
		else:
			return None

		self.abbrevs[key] = new_abbv
		self._other += 1

		return self.abbrevs[key]



Lmotor = Motor(forward=26, backward=19)
Rmotor = Motor(forward=13, backward=6)


last = []

def rC(ctrl):
	global last
	speed = 1
	#THERES MORE BUT I THINK THIS IS ALL I NEED
	xpo = ('HX', 1)
	xz = ('HX', 0)
	xno = ('HX', -1)
	ypo = ('HY', 1)
	yz = ('HY', 0)
	yno = ('HY', -1)
Exemplo n.º 20
0
# command server for driving
import socket
from gpiozero import Motor

# motor control

m1 = Motor(17, 18)
m2 = Motor(4, 14)


def stop():
    m1.stop()
    m2.stop()


def fwd(speed):
    m1.forward(speed / 255.0)
    m2.forward(speed / 255.0)


def back(speed):
    m1.backward(speed / 255.0)
    m2.backward(speed / 255.0)


def left(speed):
    m1.forward(speed / 255.0)
    m2.backward(speed / 255.0)


def right(speed):
# GPIO numbers for motor
MOTOR_PIN_FWD = 17
MOTOR_PIN_REV = 18
# GPIO pin for reed switch
REED_PIN = 4

# max speed to reduce top speed
# maximum value is 1
MAX_SPEED = 0.9
# How long to wait between speed increases
ACC_DELAY = 0.5
# How long to wait at the station
STATION_DELAY = 10

m1 = Motor(MOTOR_PIN_FWD, MOTOR_PIN_REV)
reed_switch = Button(REED_PIN)


# Go from stop to max speed
def train_speed_up(max_speed):
    speed = 0
    while speed < max_speed:
        speed += 0.1
        m1.forward(speed)
        sleep(ACC_DELAY)


def train_slow_down(current_speed):
    speed = current_speed
    while speed > 0:
Exemplo n.º 22
0
# Edit line 6 to match your chosen GPIO pin

from gpiozero import Motor, DistanceSensor
from time import sleep

motor = Motor(backward=4)
sensor = DistanceSensor(23, 24, max_distance=1, threshold_distance=0.2)

sensor.when_in_range = motor.backward
sensor.when_out_of_range = motor.close
Exemplo n.º 23
0
    def reload(self):
        super().reload()

        self.name = "RaspberryPi"
        self.duty = self.config["duty"]
        self.block_length = self.config["block_length"]
        self.duty_ratio = self.duty_ratio = self.config["raspberrypi"][
            "motor"]["duty_ratio"]
        self.turn_right_period = 0.005
        self.turn_left_period = 0.005
        self.turn_right_period = self.config["raspberrypi"]["motor"][
            "turn_right_period"]
        self.turn_left_period = self.config["raspberrypi"]["motor"][
            "turn_left_period"]

        self.servo_horizontal = self.config["raspberrypi"]["camera"][
            "servo_horizontal"]
        self.servo_vertical = self.config["raspberrypi"]["camera"][
            "servo_vertical"]

        self.grab = True
        self.servo_claw = 1
        self.servo_claw_angle_open = -60
        self.servo_claw_angle_close = 60

        self.servo_claw = self.config["raspberrypi"]["claw"]["servo"]
        self.servo_claw_angle_open = self.config["raspberrypi"]["claw"][
            "angle_open"]
        self.servo_claw_angle_close = self.config["raspberrypi"]["claw"][
            "angle_close"]

        self.servo_horizontal = 2
        self.servo_vertical = 3

        self.servo_horizontal = self.config["raspberrypi"]["camera"][
            "servo_horizontal"]
        self.servo_vertical = self.config["raspberrypi"]["camera"][
            "servo_vertical"]

        self.IN1 = 7
        self.IN2 = 8
        self.IN3 = 9
        self.IN4 = 10

        self.IN1 = self.config["raspberrypi"]["motor"]["pinout"]["IN1"]
        self.IN2 = self.config["raspberrypi"]["motor"]["pinout"]["IN2"]
        self.IN3 = self.config["raspberrypi"]["motor"]["pinout"]["IN3"]
        self.IN4 = self.config["raspberrypi"]["motor"]["pinout"]["IN4"]

        self.servos = [17, 27, 22]
        self.servos = self.config["raspberrypi"]["servos"]

        self.trigger = 18
        self.echo = 24

        self.trigger = self.config["raspberrypi"]["hcsr04"]["trigger"]
        self.echo = self.config["raspberrypi"]["hcsr04"]["echo"]

        motor_left = (self.IN1, self.IN2)
        motor_right = (self.IN3, self.IN4)

        self.motors = [
            Motor(forward=motor_left[0], backward=motor_left[1]),
            Motor(forward=motor_right[0], backward=motor_right[1])
        ]

        self.pi_servos = []
        for gpio_servo in self.servos:
            self.pi_servos.append(
                AngularServo(gpio_servo, min_angle=-90, max_angle=90))

        self.hcsr04 = DistanceSensor(echo=self.echo, trigger=self.trigger)
Exemplo n.º 24
0
import socketio
import eventlet
import eventlet.wsgi

import RPi.GPIO as GPIO
from gpiozero import Motor, OutputDevice
from time import sleep

from flask import Flask, request, send_from_directory
sio = socketio.Server()
app = Flask(__name__)

motor1 = Motor(24, 27)
motor1_enable = OutputDevice(5, initial_value=1)
# motor2 = Motor(6, 22)
# motor2_enable = OutputDevice(17, initial_value=1)
motor3 = Motor(23, 16)
motor3_enable = OutputDevice(12, initial_value=1)
motor4 = Motor(13, 18)
motor4_enable = OutputDevice(25, initial_value=1)

# @app.route('/<path:path>', methods=['POST', 'GET'])
# def serve_page(path):
#   return send_from_directory('static', path)


@app.route('/<path:path>', methods=['POST', 'GET'])
def serve_page(path):
    return send_from_directory('static', path)

Exemplo n.º 25
0
 def __init__(self, pin1, pin2):
     self.pin1 = pin1
     self.pin2 = pin2
     self.myMotor = Motor(pin1, pin2)
Exemplo n.º 26
0
class Robot:
    def __init__(self):
        self.m1 = Motor(27, 17)
        self.m2 = Motor(23, 24)
        self.m3 = Motor(6, 5)
        self.m4 = Motor(16, 13)
        self.stop_status = False
        self.data = []
        self.data.append((0, 0, 7))

    def print_data(self):
        while not self.stop_status:
            try:
                d = self.data.pop(0)
            except:
                print(len(self.data))
                continue
            print(d)

    def move(self):
        while not self.stop_status:
            if len(self.data) == 0:
                continue
            _, y, z = self.data.pop(0)
            forward_power = (y / 10)
            # 7 doesn't have any special meaning, it is just the value I get when the accelerometer is on a flat surface
            # [-1, 7) means go *left*, [8, 19] go *right*
            # As you can see, for some reason the acclerometer have more 'levels' for *right* than *left*, so it is somewhat more
            # sensitive to turn right
            if z < 7:
                self.m1.forward(max(min(forward_power, 1), 0) * 0.25)
                self.m2.forward(max(min(forward_power, 1), 0))
                self.m3.forward(max(min(forward_power, 1), 0))
                self.m4.forward(max(min(forward_power, 1), 0) * 0.25)
            elif z > 7:
                self.m1.forward(max(min(forward_power, 1), 0))
                self.m2.forward(max(min(forward_power, 1), 0) * 0.25)
                self.m3.forward(max(min(forward_power, 1), 0) * 0.25)
                self.m4.forward(max(min(forward_power, 1), 0))
            else:
                self.m1.forward(max(min(forward_power, 1), 0))
                self.m2.forward(max(min(forward_power, 1), 0))
                self.m3.forward(max(min(forward_power, 1), 0))
                self.m4.forward(max(min(forward_power, 1), 0))
Exemplo n.º 27
0
# Edit line 6 to match your chosen GPIO pin

from gpiozero import Motor, DistanceSensor
from time import sleep

motor = Motor(forward=4)
sensor = DistanceSensor(23,24, max_distance=1, threshold_distance=0.2)

sensor.when_in_range = motor.forward
sensor.when_out_of_range = motor.close
Exemplo n.º 28
0
from gpiozero import Motor
from gpiozero.pins.pigpio import PiGPIOFactory
import csv
import time
import cv2

turn_speed = 0.6
drive_speed = 0.2
remote_factory = PiGPIOFactory(host='192.168.1.130')
motor_1 = Motor(forward=19, backward=13)
motor_2 = Motor(forward=6, backward=5)
drive_forward = motor_1.forward
drive_backward = motor_1.backward
turn_left = motor_2.forward
turn_right = motor_2.backward

turn_left(0)
turn_right(0)
drive_forward(0)
Exemplo n.º 29
0
from gpiozero import Motor, LED
from time import sleep

switch = LED(4)
switch.on()

motora = Motor(forward=22, backward=17)
motorb = Motor(forward=18, backward=27)

motora.forward()
motorb.forward()
sleep(3)
Exemplo n.º 30
0
'''
https://gpiozero.readthedocs.io/en/stable/recipes.html
http://raspberry.io/projects/view/reading-and-writing-from-gpio-ports-from-python/
https://pimylifeup.com/raspberry-pi-gpio/
'''

from gpiozero import Motor
from time import sleep

motor = Motor(forward=4, backward=14)


def isopen():
    return True


def open():
    motor.forward()
    pass


def close():
    motor.backward()
    pass


if __name__ == "__main__":
    print('run as it self')
    while True:
        open()
        sleep(1)
Exemplo n.º 31
0
from gpiozero import Motor
#from gpiozero.Pin import
#import RPi.GPIO as GPIO
from encoders import d_move, refresh

ml = Motor(2, 3)
mr = Motor(14, 15)
ml.stop()
mr.stop()
"""
I  am assuming that the initial location of the bot
is facing upwards at 0,0
the bot can make only 90 degree turns
"""



direction = 'n' # n,e,w,s for different locations that it is facing
usfront = 20

try:
	# ADD SOMETHING TO DO WHEN US IS LESS THAN 5;
    def forward():
    	if usfront <= 5:
            print "error"
    	else:
            ml.forward()
            mr.forward()

    def sstop():
        ml.stop()
Exemplo n.º 32
0
from gpiozero import Motor
from time import sleep

motor = Motor(forward=20, backward=21, enable=16, pwm=True)

while True:
    speed = 0.5
    motor.forward(speed)
    sleep(5)
    motor.backward(speed)
    sleep(5)
Exemplo n.º 33
0
import dynamodbfanlog
import dynamodbtemperature
import jsonconverter as jsonc


# Custom MQTT message callback
def customCallback(client, userdata, message):
    print("Received a new message: ")
    print(message.payload)
    print("from topic: ")
    print(message.topic)
    print("--------------\n\n")


lcd = LCD()
motor2 = Motor(20, 22, pwm=True)

full_path = '/home/pi/Desktop/image1.jpg'
file_name = 'image1.jpg'

host = "a3c16s480tb79n-ats.iot.us-east-1.amazonaws.com"
rootCAPath = "rootca.pem"
certificatePath = "certificate.pem.crt"
privateKeyPath = "private.pem.key"

BUCKET = 'sp-p1650688-s3-bucket'  # replace with your own unique bucket name
location = {'LocationConstraint': 'us-east-1'}
file_path = "/home/pi/Desktop"
file_name = "test.jpg"
best_bet_item = "Unknown"
Exemplo n.º 34
0
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()
Exemplo n.º 35
0
#!/usr/bin/env python
# coding=UTF-8

from gpiozero import Motor
from gpiozero import Button
import datetime
import time
import logging

TIME_CLOSE = 99
TIME_OPEN = 69
STATUSFILENAME = "/home/pi/domopoules/chickenpython/status.txt"
motor = Motor(forward=17, backward=22)
button = Button(2)

def init():
    logging.basicConfig(filename='chicken.log', level=logging.DEBUG, format='%(asctime)s — %(name)s — %(levelname)s — %(message)s')

def print_and_log(message): 
    logging.info(message)
    print message

def info_button_pressed():
    print_and_log("Door button pressed")

button.when_pressed = info_button_pressed

def read_status():
    file = open(STATUSFILENAME, "r")
    status = file.readline()
    file.close()
Exemplo n.º 36
0
from gpiozero import Motor, OutputDevice
from time import sleep

motor2 = Motor(6, 22)
motor2_enable = OutputDevice(17, initial_value=1)
motor3 = Motor(23, 16)
motor3_enable = OutputDevice(12, initial_value=1)

turn_time=0.95

def forward():
    motor2.forward()
    motor3.forward()
    sleep(1.5)

def backward():
    motor3.backward()
    motor2.backward()
    sleep(1.5)

def left_turn():
    motor3.forward()
    motor2.backward()
    sleep(turn_time)

def right_turn():
    motor3.backward()
    motor2.forward()
    sleep(turn_time)

def eight():
Exemplo n.º 37
0
from gpiozero import Motor
import time

motorr = Motor(forward=22, backward=23)
motorl = Motor(forward=18, backward=17)

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)