def __init__(self, fl, fr, rl, rr):
self._fl = Motor(*fl)
self._fr = Motor(*fr)
self._rl = Motor(*rl)
self._rr = Motor(*rr)
self._all = [[self._fl, self._fr], [self._rl, self._rr]]
#refer to GPIO pins allocations here: https://www.raspberrypi.org/documentation/usage/gpio/
#the 'robot' class of the gpiozero library is used below: https://gpiozero.readthedocs.io/en/stable/recipes.html#robot
#the robot should first move forward, then spin right, then spin left, then go backwards.
#if this works as expected, your GPIO mapping and motor driver board wiring is correct
#first of all, import the Robot class from the 'gpiozero' library
from gpiozero import Robot, Motor
#then import the 'sleep' class from the 'time' library (so we can add pauses in our program)
from time import sleep
#define a robot (it's called Burt! :-) ), with the GPIO pin mapping as per the GPIO in the RobotV2.md file
burt_the_robot = Robot(
left=(8, 7), right=(21, 20)
) # dont change this pin mapping, otherwise your robot will be different to the others!
gun_motor = Motor(13, 19)
#set the speed. 1 = 100%, 0.5 = 50% and so on...
speed = 0.7
sleep(2)
#go forward indefinitely
burt_the_robot.forward(speed)
#sleep for 2seconds
sleep(1)
#spin right indefinitely
burt_the_robot.right(speed)
#sleep for 2seconds
class ControlModule:
if sys.platform == 'win32':
Device.pin_factory = MockFactory(pin_class=MockPWMPin)
pool = concurrent.futures.ProcessPoolExecutor()
#Name of Individual MOTORS
motor0 = Motor(forward=22, backward=27, enable=17)
motor1 = Motor(forward=23, backward=24, enable=25)
motor2 = Motor(forward=9, backward=11, enable=10)
motor3 = Motor(forward=8, backward=7, enable=12)
motors = [motor0, motor1, motor2, motor3]
button0 = Button(2)
button1 = Button(3)
button2 = Button(14)
buttons = [button0, button1, button2]
led0 = LED(15)
led1 = LED(20)
led2 = LED(21)
leds = [led0, led1, led2]
debugled0 = LED(13)
debugled1 = LED(19)
debugled2 = LED(16)
debugled3 = LED(26)
debugleds = [debugled0, debugled1, debugled2, debugled3]
# if sys.platform == 'win32':
# Device.pin_factory.pin(16).drive_low()
iterationNumber = 1
currentRun = 0
running = 0
lock = Lock()
def __init__(self, goroutine):
self.go = goroutine
def startRun(self):
with self.lock:
if (self.running == 1):
return 0
self.iterationNumber = self.iterationNumber + 1
self.running = 1
self.currentRun = self.iterationNumber
return self.iterationNumber
def stopRun(self):
with self.lock:
self.iterationNumber = self.iterationNumber + 1
self.running = 0
return self.iterationNumber
def stopNow(self):
with self.lock:
self.iterationNumber = self.iterationNumber + 1
return self.iterationNumber
def isCancelled(self):
with self.lock:
return self.iterationNumber != self.currentRun
def isBusy(self):
with self.lock:
return self.running == 1
def isButtonPressed(self, buttonNumber):
button = self.buttons[buttonNumber]
result = button.is_pressed
return result
def enableLed(self, ledNumber):
led = self.leds[ledNumber]
led.on()
def disableLed(self, ledNumber):
led = self.leds[ledNumber]
led.off()
def debugOn(self, ledNumber):
led = self.debugleds[ledNumber]
led.on()
def debugOff(self, ledNumber):
led = self.debugleds[ledNumber]
led.off()
async def spinMotor(self,
motorNumber,
duration,
direction=1,
stopRoutine=None):
if (self.isCancelled()):
return "Cancelled"
if stopRoutine:
if stopRoutine():
return "Stopped"
motor = self.motors[motorNumber]
if (direction == 1):
print("Forward " + str(motorNumber))
motor.forward(1)
else:
print("Backward " + str(motorNumber))
motor.backward(1)
remainingDuration = duration
while remainingDuration > 0:
if stopRoutine:
if stopRoutine():
break
await asyncio.sleep(0.05)
remainingDuration -= 0.05
if (self.isCancelled()):
break
motor.stop()
print("Stopped spinning " + str(motorNumber))
return "Done"
def target(self):
print("Target thread:" + str(threading.current_thread().ident))
try:
self.startRun()
loop = asyncio.new_event_loop()
print("Target")
print(threading.current_thread().ident)
loop.run_until_complete(self.go())
print("Target done")
finally:
self.stopRun()
def start(self):
runId = self.startRun()
if (runId == 0):
print("Already running")
return "Already running"
print("Start thread:" + str(threading.current_thread().ident))
thread = threading.Thread(target=self.target)
thread.start()
return "Starting execution"
def stop(self):
self.stopNow()
return "Stopped"
from gpiozero import Motor
motor1 = Motor(4, 14)
motor2 = Motor(17, 27)
# Dies sind nur Umschreibungen der ursprünglichen Funktionen,
# um sie zu übersetzen und verständlicher zu machen
# (hoffentlich)
def motorRechts (motor, geschwindigkeit):
if geschwindigkeit <= 100:
motor.forward(geschwindigkeit / 100)
def motorLinks (motor, geschwindigkeit):
if geschwindigkeit <= 100:
motor.forward(geschwindigkeit / 100)
def motorUmdrehen (motor):
motor.reverse()
# Setzt Geschwindigkeit zwischen 0 und 100 %
def motor1Links (geschwindigkeit = 50):
motorLinks(motor1, geschwindigkeit)
def motor1Rechts (geschwindigkeit = 50):
motorRechts(motor1, geschwindigkeit)
def motor1Umdrehen ():
motorUmdrehen (motor1)
def motor1Stop ():
from PIL import Image
from resizeimage import resizeimage
import sounddevice as sd
import soundfile as sf
import serial
import os
import pygame, sys
from pygame.locals import *
import pygame.camera
width = 320
height = 256
wavfile = 'x.wav'
led = LED(4)
servo = AngularServo(27, min_angle=0, max_angle=180)
fb_motor = Motor(17, 18)
lr_motor = Motor(22, 23)
class MyHandler(FileSystemEventHandler):
def on_modified(self, event):
#path = r'C:\Users\Gil\AppData\Local\JS8Call - sdr\DIRECTED.TXT'
path = r"/home/pi/.local/share/JS8Call/DIRECTED.TXT"
log(f"event type: {event.event_type} path : {event.src_path}"
) #print the event and the file name
if event.event_type == "modified" and event.src_path == path: #if this is the file that was changed
log_file = pd.read_csv(
path, sep='\t',
header=None) #read it (it does not have a header)
last_record = log_file.tail(1) #take the last record
raw_data = last_record[4].to_string(
lpid=PID(Kp=KP,Ki=KI,Kd=KD,setpoint=sp,sample_time=pid_sample_time,output_limits=(0,1),auto_mode=True)
rpid=PID(Kp=KP,Ki=KI,Kd=KD,setpoint=sp,sample_time=pid_sample_time,output_limits=(0,1),auto_mode=True)
motl_a_pin=4
motl_b_pin=12
motr_a_pin=1
motr_b_pin=15
servo_pin=14
enc_l_pin=18
enc_r_pin=0
enc_l_rate=0
enc_r_rate=0
motl= Motor(motl_a_pin,motl_b_pin)
motr = Motor(motr_a_pin, motr_b_pin)
el=Encoder(enc_l_pin)
er=Encoder(enc_r_pin)
motl.forward(1)
# motr.forward(0.2)
l_pwr=0
def get_encoder_reading():
global enc_l_rate,enc_r_rate,l_pwr
while True:
enc_l_rate=el.value
enc_r_rate=er.value
print('L : ',enc_l_rate)
el.reset()
import RPi.GPIO as GPIO
from gpiozero import Motor
from time import sleep
pin = 18
GPIO.setmode(GPIO.BCM)
GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
motor = Motor(26, 19)
def rotate(time):
motor.forward(0.9)
sleep(time)
motor.stop()
def get_state():
pin_state = GPIO.input(pin)
if pin_state == False:
print("AM")
return "AM"
else:
print("PM")
return "PM"
from gpiozero import Motor
from flask import Flask, render_template, request, jsonify
import datetime
import time
import utils
import hit
motor1 = Motor(8, 7)
motor2 = Motor(24, 23)
diff = 0.75
sstop = 0.092
startTime = datetime.datetime.now().strftime("%Y-%b-%d %H:%M:%S")
app = Flask(__name__, static_url_path='')
@app.route("/")
def show_details():
global startTime
return "<html>" + \
"<head><title>Docker + Flask Demo</title></head>" + \
"<body>" + \
"<table>" + \
"<tr><td> Start Time </td> <td>" + startTime + "</td> </tr>" \
"<tr><td> Hostname </td> <td>" + utils.gethostname() + "</td> </tr>" \
"<tr><td> Local Address </td> <td>" + utils.getlocaladdress() + "</td> </tr>" \
"<tr><td> Remote Address </td> <td>" + request.remote_addr + "</td> </tr>" \
"<tr><td> Server Hit </td> <td>" + str(hit.getServerHitCount()) + "</td> </tr>" \
"<tr><td> JSON </td> <td> <a href='/json'>JSON</a> </td> </tr>" \
from gpiozero import Button
from gpiozero import Motor
import time
print(time.strftime("%H"))
print(time.strftime("%M"))
print(time.strftime("%S"))
button = Button(2)
motor = Motor(forward=23, backward=24)
minute = "30"
hour = "07"
timeToStop = 60
currentTime = None
alarmCleared = False
def main():
while True:
global currentTime
global alarmCleared
print(
str(time.strftime("%H")) + " " + str(time.strftime("%M")) + " " +
str(time.strftime("%S")))
print(hour + " " + minute)
def __init__(self):
self.motor_lx = Motor(18, 24)
self.motor_rx = Motor(23, 25)
from gpiozero import Motor
from time import sleep
motorA = Motor(forward=23, backward=24)
motorB = Motor(forward=27, backward=22)
while True:
motorA.forward()
motorB.forward()
sleep(5)
motorA.stop()
motorB.stop()
sleep(1)
motorA.backward()
motorB.backward()
sleep(5)
motorA.stop()
motorB.stop()
sleep(1)
import time
import RPi.GPIO as GPIO
from gpiozero import Motor
from pynput.keyboard import Key, Listener #key board realease and press
#import threading
# seting the pins for use!
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.cleanup()
motor_left = Motor(forward=3, backward=2)
motor_right = Motor(forward=27, backward=22)
GPIO.setup(4, GPIO.OUT) #left enabal
GPIO.setup(17, GPIO.OUT) #right enabal
#GPIO.output(4, True)
#GPIO.output(17, True)
def froward():
motor_left.forward()
motor_right.forward()
GPIO.output(4, True)
GPIO.output(17, True)
import json
import threading
from subprocess import call
from datetime import datetime
from gpiozero import LED, Button, Motor
SERVER_IP = "192.168.0.102"
SERVER_PORT = 5005
MOTION_STOP_SECS = 0.8
MOTION_CHANGE_INTERVAL = 0.05
logging.basicConfig(level=logging.INFO)
statusLed = LED(24)
killButton = Button(21)
motorLeft = Motor(4, 3)
motorRight = Motor(16, 20)
class Communicator:
def __init__(self, motionController):
self.motionController = motionController
self.motionController.start()
def connect(self):
self.serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
while True:
logging.info("Trying to connect to a server %s:%s", SERVER_IP,
SERVER_PORT)
try:
self.serverSocket.connect((SERVER_IP, SERVER_PORT))
#!/usr/bin/python from gpiozero import Motor from time import sleep from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer from urlparse import parse_qs import threading # robot motor pins motorL = Motor(2, 3) motorR = Motor(4, 17) # webserver configuration hostName = '' serverPort = 8080 # populate page content page = "" with open( 'page.html', 'r' ) as file: page = file.read() # global variables direction = '' notStopped = True class MyServer( BaseHTTPRequestHandler ): def do_GET( self ): self.send_response( 200 ) self.send_header( "Content-type", "text/html; charset=utf-8" ) self.end_headers() self.wfile.write( page ) def do_POST( self ):
def __init__(self, config: dict):
super().__init__("motors")
self.motors = {}
for motor in config['motors']:
self.motors[motor['name']] = Motor(motor['pin1'], motor['pin2'],
motor['enable'], True)
import os
from gpiozero import Motor
from time import sleep
from config import *
motor = Motor(forward = fan.pin)
# Return CPU temperature as a character string
def getCPUtemp():
res = os.popen('vcgencmd measure_temp').readline()
return(res.replace("temp=","").replace("'C\n",""))
while True:
temp = getCPUtemp()
if temp > 45:
try:
motor.forward()
except:
pass
else:
try:
motor.off()
except:
pass
from gpiozero import Motor
#from gpiozero.Pin import
#import RPi.GPIO as GPIO
from encoders import d_move, refresh
from ultrasonic import ultra
from anomaly import check
mr = Motor(2, 3)
ml = 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
"""
lm = 20
rm = 14.6
direction = 'n' # n,e,w,s for different locations that it is facing
try:
def forward():
ml.forward(0.553)
mr.forward(0.5)
def sstop():
ml.stop()
mr.stop()
########################################################################
# Import modules #
########################################################################
import os
import logging
import random
from time import sleep
from gpiozero import Motor, Button, OutputDevice
import pygame
########################################################################
# Variables #
########################################################################
BRACHIOSAURUS_MOTOR = Motor(23, 18, True) # forward, backward, pwm
BRACHIOSAURUS_MOTOR_ENABLE = OutputDevice(24)
BLUE_BUTTON = Button(25)
RED_BUTTON = Button(9)
########################################################################
# Initialize #
########################################################################
pygame.mixer.init()
logging.basicConfig(filename='Files/brachiosaurus.log',
filemode='w',
level=logging.INFO,
format='%(asctime)s %(levelname)s: %(message)s',
datefmt='%m/%d/%y %I:%M:%S %p:')
def __init__(self, *pins):
self.motors = []
for pin in pins:
if len(pin) != 2:
raise Exception('MotorGroup need pin pairs')
self.motors.append(Motor(pin[0], pin[1]))
from gpiozero import Motor
from time import sleep
left_motor = Motor(14, 4)
right_motor = Motor(20, 26)
speed = 0.4
if __name__ == '__main__':
left_motor.forward(speed)
right_motor.backward(speed)
sleep(10)
def __init__(self):
super(SmartCarMotorController, self).__init__()
self._left_motor = Motor(4, 14)
self._right_motor = Motor(18, 17)
from gpiozero import Motor
from gpiozero import AngularServo
import time
import pigpio
motorL = Motor(14, 15)
motorR = Motor(23, 24)
pi = pigpio.pi()
angle = 90
# servo = AngularServo(18, min_angle=0, max_angle=120, min_pulse_width=0.9/1000, max_pulse_width=2.1/1000)
def setAngle(ang):
global angle
#angle comes in as 0-120
if (angle > 120): #safety
angle = 120
if (angle < 32):
angle = 32
#pulsewidth is between 900 - 2100 us
conv = ((angle / 120) *
1200) + 900 # + 900 to account for the min of the pulsewidth
pi.set_servo_pulsewidth(18, conv)
def tilt(inc):
global angle
angle += inc
setAngle(angle)
motor2.forward()
sleep(1)
led_blue_22.off()
motor2.stop()
motor1.forward()
sleep(1)
led_red_18.on()
motor1.backward()
motor2.backward()
sleep(1)
led_red_18.off()
motor1 = Motor(forward=25, backward=23)
motor2 = Motor(forward=13, backward=19)
led_red_18 = LED(18)
led_blue_22 = LED(22)
#sleep(3)
#for i in range(3):
# led_blue_22.on()
# motor1.forward()
# motor2.forward()
# sleep(1)
# led_blue_22.off()
# motor2.stop()
# motor1.forward()
# sleep(1)
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()
from gpiozero import Motor
from gpiozero import Button
import time
TIME_CLOSE = 99
TIME_OPEN = 69
motor = Motor(forward=17, backward=22)
button = Button(2)
button.when_pressed = info_button_pressed
def open_door():
motor.forward()
time.sleep(TIME_OPEN)
motor.stop()
def close_door():
time_spent = 0
motor.backward()
while not button.is_pressed and time_spent < TIME_CLOSE:
time.sleep(1)
time_spent += 1
motor.stop()
# Pins motordrivare
# 1. +5V
# 2. EnA - active high
# 3. In1 - MT1
# 4. In2 - MT1
# 5. EnB - active high
# 6. In3 - MT2
# 7. In4 - MT2
# 8. GND
# Kabel med text - + - +12V
from gpiozero import Motor
motor = Motor(17, 27)
pwr = 1 # Motor power -1 to 1
# Elimination of the deadzone
# To evaluate the minimum value, set minVal to 0
minVal = 0.0 # The smallest value that gives non zero rotation velocity
zero = 0.0
val = minVal + abs(pwr) * (1 - minVal) # Power sent to the motor
if val > 1:
val = 1
if pwr > zero:
motor.forward(val)
elif pwr < -1 * zero:
motor.backward(val)
#Control de motor
from gpiozero import Motor
from time import sleep
motor = Motor(forward=4, backward=14)
while True:
Motor.forward()
sleep(5)
motor.backward()
sleep(5)
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)
from gpiozero import Motor
from time import sleep
motor = Motor(forward=8, backward=7)
while True:
motor.forward()
sleep(5)
motor.backward()
sleep(5)
from gpiozero import Motor
from time import sleep
motorRight = Motor(forward=10, backward=9)
motorLeft = Motor(forward=8, backward=7)
def stop():
motorRight.stop()
motorLeft.stop()
def forward(t):
motorRight.forward()
motorLeft.forward()
sleep(t)
def backward(t):
motorRight.backward()
motorLeft.backward()
sleep(t)
def left(t):
motorRight.backward()
motorLeft.forward()
sleep(t)
def right(t):
