def __init__(self):
defaultCorretion = 0.45
maxPW=(2.0+defaultCorretion)/1000
minPW=(1.0-defaultCorretion)/1000
self.servo1 = GZ.Servo(self.__servo1Pin, min_pulse_width=minPW, max_pulse_width=maxPW, frame_width = 20/1000)
self.servo2 = GZ.Servo(self.__servo2Pin, min_pulse_width=minPW, max_pulse_width=maxPW, frame_width = 20/1000)
print ("Waiting for servo start")
self.servo1.value = -1
time.sleep(0.5)
self.servo2.value = 1
time.sleep(0.5)
self.servo1.detach()
self.servo2.detach()
self.led1 = GZ.LED(self.__led1Pin)
self.led2 = GZ.LED(self.__led2Pin)
self.switchModeLed = GZ.LED(self.__switchModeLedPin)
self.button1 = GZ.Button(self.__button1Pin, pull_up = True)
self.button2 = GZ.Button(self.__button2Pin, pull_up = True)
self.pSensor = GZ.Button(self.__pSensorPin)
self.button1.when_pressed = self.pressButton1
self.button2.when_pressed = self.pressButton2
self.pSensor.when_pressed = self.detectObject
# init stepper motor
stepperMotor_pins = (14, 15, 18)
direction = 20
step = 21
self.stepperMotor = RpiMotorLib.A4988Nema(direction, step, stepperMotor_pins, "A4988")
def __init__(self):
self.sright = gpiozero.Servo(21)
self.sleft = gpiozero.Servo(20)
self.ip = '192.168.1.255'
self.port = 9001
self.running = True
self.socksend = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sockrecv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sockrecv.bind(('0.0.0.0', self.port))
self.data = b''
self.recv_thread = threading.Thread(target=self.recv_loop, daemon=True)
self.recv_thread.start()
def __init__(self, servo_pin=12): self.factory = PiGPIOFactory() self.servo_pin = servo_pin self.servo = gpiozero.Servo(servo_pin, pin_factory=self.factory) self.last_position = 0 self.moving = False self.rotate(0)
def __init__(self, steprefresh=1):
# Variables
self.servotime = 0.5
self.steptime = 0.01 # 100 Hz step frequency
self.steprefresh = steprefresh # timespan of stepping sequence [s]
self.just_length = 24 # justification length
# Initialization
self.SERVO_1 = gpiozero.Servo(24)
self.SERVO_2 = gpiozero.Servo(25)
self.MOSFET1_G = gpiozero.DigitalOutputDevice(12, initial_value=False)
self.MOSFET2_G = gpiozero.DigitalOutputDevice(16, initial_value=False)
self.MOSFET3_G = gpiozero.DigitalOutputDevice(20, initial_value=False)
self.MOSFET4_G = gpiozero.DigitalOutputDevice(21, initial_value=False)
self.COIL_1 = gpiozero.DigitalOutputDevice(17, initial_value=False)
self.COIL_2 = gpiozero.DigitalOutputDevice(27, initial_value=False)
self.COIL_3 = gpiozero.DigitalOutputDevice(22, initial_value=False)
self.COIL_4 = gpiozero.DigitalOutputDevice(5, initial_value=False)
self.LIGHT = gpiozero.DigitalOutputDevice(13, initial_value=False)
self.BUZZER = gpiozero.DigitalOutputDevice(6, initial_value=False)
self.SWITCH_1 = gpiozero.Button(14)
self.SWITCH_2 = gpiozero.Button(15)
self.SWITCH_3 = gpiozero.Button(18)
self.SWITCH_4 = gpiozero.Button(23)
self.SWITCH_5 = gpiozero.Button(26) # BCM 26 (Mission Cont Shutdown)
self.SWITCH_6 = gpiozero.Button(19) # BCM 19 (Limit switch input)
self.BATTERY = gpiozero.MCP3008(channel=0)
self.AMBIENT = gpiozero.MCP3008(channel=1)
self.BUTTON1 = gpiozero.MCP3008(channel=2)
self.BUTTON2 = gpiozero.MCP3008(channel=3)
self.POTMETR = gpiozero.MCP3008(channel=4)
self.SWITCH_7 = gpiozero.MCP3008(channel=5) # Spare limit switch input
self.SWITCH_8 = gpiozero.MCP3008(channel=6) # Spare limit switch input
self.COILS_FWD = [self.COIL_1, self.COIL_2, self.COIL_3, self.COIL_4]
self.COILS_REV = [self.COIL_4, self.COIL_3, self.COIL_2, self.COIL_1]
self.SWITCHES = [
self.SWITCH_1, self.SWITCH_2, self.SWITCH_3, self.SWITCH_4
]
self.MOSFETS = [
self.MOSFET1_G, self.MOSFET2_G, self.MOSFET3_G, self.MOSFET4_G
]
def servoSweep():
servo = gz.Servo(17)
while True:
servo.min()
time.sleep(3)
servo.mid()
time.sleep(2)
servo.max()
time.sleep(3)
def servo_sweep():
servo = gz.Servo(17)
while True:
servo.min()
time.sleep(2)
print("Min")
servo.mid()
time.sleep(2)
servo.max()
time.sleep(2)
def __init__(self, gpio_interface, control_pin, min_pulse, max_pulse):
self.gpio_interface = gpio_interface
self.control_pin = control_pin
self.angle = ANGLE_DEFAULT
if gpio_interface == USE_RPI_GPIO:
status.is_rpi_gpio_used = True
RPi.GPIO.setmode(RPi.GPIO.BCM)
RPi.GPIO.setwarnings(False)
RPi.GPIO.setup(control_pin, RPi.GPIO.OUT)
self.pwm = RPi.GPIO.PWM(control_pin, SERVO_FREQUENCY)
servo_period = (1 / SERVO_FREQUENCY) * 1000000
min_duty_cycle = min_pulse * 100 / servo_period
max_duty_cycle = max_pulse * 100 / servo_period
self.pwm_ratio = (max_duty_cycle - min_duty_cycle) / (ANGLE_MAX -
ANGLE_MIN)
self.center_pwm = (max_duty_cycle + min_duty_cycle) / 2
elif gpio_interface == USE_RPI_ZERO:
self.pwm = gpiozero.Servo(control_pin,
initial_value=ANGLE_DEFAULT,
min_pulse_width=min_pulse / 1000000,
max_pulse_width=max_pulse / 1000000,
frame_width=1 / SERVO_FREQUENCY)
self.pwm_ratio = 2 / (ANGLE_MAX - ANGLE_MIN)
self.center_pwm = 0
elif gpio_interface == USE_PI_GPIO:
if not utils.is_process_running('pigpiod'):
log(ERROR, 'ServoMotor: pigpiod process not started')
os._exit(3)
self.pigpio = pigpio.pi()
self.pigpio.set_mode(control_pin, pigpio.OUTPUT)
self.pigpio.set_PWM_frequency(control_pin, SERVO_FREQUENCY)
self.pwm_ratio = (max_pulse - min_pulse) / (ANGLE_MAX - ANGLE_MIN)
self.center_pwm = (max_pulse + min_pulse) / 2
self.is_started = False
self.set_angle(ANGLE_DEFAULT)
def roll_and_take_image():
s = gpiozero.Servo(14, min_pulse_width=1 /
2000) # Default pulse isn't getting full 180 degrees
s.min()
sleep(0.5)
s.value = 0.9
sleep(0.5)
s.close(
) # Close it so it doesn't rattle in there - this is also the problem with the camera interfering :/
led.on()
with io.BytesIO() as stream:
with PiCamera() as camera:
camera.resolution = (720, 480)
camera.capture(stream, 'jpeg')
bytes = stream.getvalue()
led.off()
return bytes
def execute_motors(outpin,NOT):
'''pwm = GPIO.PWM(outpin,50)
pwm.start(0)
for run in range(NOT):
duty = 360/18 +2
GPIO.output(outpin,True)
pwm.ChangeDutyCycle(duty)
sleep(1)
GPIO.output(03,False)
pwm.ChangeDutyCycle(0)
pwm.stop()
return None'''
"""
servo = gpiozero.Servo(outpin)
for i in range(2*NOT):
servo.min()
sleep(1)
servo.max()
sleep(1)
"""
servo = gpiozero.Servo(outpin,min_pulse_width=0.0005,max_pulse_width=0.001)
print(servo.value)
servo.min()
print(servo.value)
for i in range(NOT):
if (i%2 ==0):
print("Dispensing one unit...")
servo.min()
print(servo.value)
sleep(1)
servo.max()
print(servo.value)
sleep(1)
else:
print("Dispensing one unit...")
servo.min()
print(servo.value)
sleep(1)
servo.max()
print(servo.value)
sleep(1)
def __init__(self, servo_pin):
self.factory = PiGPIOFactory()
self.servo_pin = servo_pin
self.servo = gpiozero.Servo(servo_pin, pin_factory=self.factory)
value = int(value)
key = bytes(key, 'utf8')
value = bytes.fromhex(hex(value)[2:].zfill(2))
ser.write(key)
ser.write(value)
ser.flush()
#buzzer = gpiozero.TonalBuzzer(21)
#led1 = gpiozero.PWMLED(23)
#led2 = gpiozero.LED(23)
led3 = gpiozero.LED(25)
led4 = gpiozero.LED(8)
#base_servo = gpiozero.Servo(17)
claw_servo = gpiozero.Servo(5) # the Klaw!
arm_maj_servo = gpiozero.Servo(27)
arm_min_servo = gpiozero.Servo(22)
#arm = meArm.meArm()
#arm.begin()
def on_key(key):
def decorator(func):
key_mapping[key] = key_mapping.get(key, []) + [func]
return func
return decorator
# !/usr/bin/env python3 # -*- coding: utf-8 -*- from time import sleep import gpiozero SERVO_PIN = 18 WAIT_TIME = 1 servo = gpiozero.Servo(SERVO_PIN) servo.min() # 最小の位置 sleep(WAIT_TIME) servo.mid() # 中間の位置 sleep(WAIT_TIME) servo.max() # 最大の位置 sleep(WAIT_TIME)
#! python3 # This script is for testing the Mars Rover 2020 from time import sleep import gpiozero # gpiozero.Servo(pin, *, initial_value=0, min_pulse_width=1/1000, # max_pulse_width=2/1000, frame_width=20/1000, pin_factory=None) # Variables servotime = 3 steptime = 0.01 # Initialization SERVO_1 = gpiozero.Servo(24) SERVO_2 = gpiozero.Servo(25) MOSFET1_G = gpiozero.DigitalOutputDevice(12, initial_value=False) MOSFET2_G = gpiozero.DigitalOutputDevice(16, initial_value=False) MOSFET3_G = gpiozero.DigitalOutputDevice(20, initial_value=False) MOSFET4_G = gpiozero.DigitalOutputDevice(21, initial_value=False) COIL_1 = gpiozero.DigitalOutputDevice(17, initial_value=False) COIL_2 = gpiozero.DigitalOutputDevice(27, initial_value=False) COIL_3 = gpiozero.DigitalOutputDevice(22, initial_value=False) COIL_4 = gpiozero.DigitalOutputDevice(5, initial_value=False) IR_LED = gpiozero.DigitalOutputDevice(6, initial_value=False) BUZZER = gpiozero.DigitalOutputDevice(13, initial_value=False) COLORS = gpiozero.DigitalOutputDevice(19, initial_value=False)
fmt='%(created)s %(levelname)-8s %(name)s:%(funcName)s: %(message)s')
file_handler.setFormatter(file_formatter)
# create logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# add the handlers to the logger
logger.addHandler(console_handler)
logger.addHandler(except_handler)
logger.addHandler(file_handler)
# log initial message
logger.info('Start of the log of {}'.format(conf.name))
# in case the pin number is None (null in json), a dummy object is assigned
hatch = (gpiozero.Servo(
conf.hatch_pin, conf.hatch_closed, pin_factory=PiGPIOFactory())
if conf.hatch_pin else dummy.Output('hatch'))
buzzer = (BeepingTonalBuzzer(conf.buzzer_pin, octaves=4)
if conf.buzzer_pin else dummy.Output('buzzer'))
status_LED = (gpiozero.RGBLED(*conf.status_LED_pins, pwm=True)
if all(conf.status_LED_pins) else dummy.Output('status_LED'))
arm_switch = (gpiozero.Button(conf.arm_switch_pin)
if conf.arm_switch_pin else dummy.Input('arm_switch'))
breakwire = (gpiozero.Button(conf.breakwire_pin)
if conf.breakwire_pin else dummy.Input('breakwire'))
gpiobjects = [hatch, buzzer, status_LED, arm_switch]
imu = altimu10v5.IMU()
# automatic dummy assignment if the sensors are not present, to allow for easier testing
if sensors_present():
baro = Sensor('baro', conf.sensor_intervals['baro'],
# import numpy
import gpiozero
from skyfield import api as skyfapi
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
UTC = timezone('UTC')
SATS = skyfapi.load.tle('https://celestrak.com/NORAD/elements/resource.txt')
SAT = SATS['HODOYOSHI-1']
TS = skyfapi.load.timescale()
TOKYO = skyfapi.Topos(latitude='35.688926 N', longitude='139.774214 W')
# min pulse 0.5 ms max pulse 2.4 ms
SERVO = gpiozero.Servo(16,
min_pulse_width=0.5 / 1000,
max_pulse_width=2.4 / 1000)
class Stepper:
"Stepper motor helper class"
STEPPER_RESOLUTION = 200 # 1.8deg per step
MICROSTEPS = 8
STEP = gpiozero.OutputDevice(20)
DIR = gpiozero.OutputDevice(21)
PERIOD = 1 / 2000 # bitbanged stepper STEP signal length
def __init__(self):
self.current_step = 0
self.current_direction_is_forward = True
import gpiozero as zero
from time import sleep
cor = .002
maxPW = (2.0 + cor) / 1000
minPW = (1.0 - cor) / 1000
servo = zero.Servo(17, min_pulse_width=minPW, max_pulse_width=maxPW)
while True:
servo.min()
print("min")
print(servo.value)
sleep(2)
servo.max()
print("max")
print(servo.value)
sleep(2)
servo.mid()
print("mid")
print(servo.value)
sleep(2)
import numpy as np
from scipy import stats
from time import sleep
from picamera import PiCamera
import picamera.array
import cv2
import gpiozero
#initialize list containing servo objects and set them all to min position
servo_list = []
for k in range(8, 16):
servo = gpiozero.Servo(k)
servo_list.append(servo)
servo.min()
#calculates the sensitivity for the algorithm which turn the images into
#song. is run once at the start of the main algorithm
#works by first placing a blank piece of paper in front of the camera
#a picture is then taken and the value of the darkest pixel of the paper is
#taken this value is then the thresehold value for deciding if a pixel value
#is filled in or not
def calibrate(cam):
with picamera.array.PiRGBArray(cam) as stream:
cam.capture(stream, format='bgr')
image = stream.array
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
image = image[90:430, 310:330]
minval = int(np.min(image))
return minval
import gpiozero import time import keyboard running = True pressed = "" base = gpiozero.Servo(4) gripper = gpiozero.Servo(10) elbow = gpiozero.Servo(17) shoulder = gpiozero.Servo(22) base_angle = 0 gripper_angle = 0 elbow_angle = 0 shoulder_angle = 0 step = 0.1 max = 1 min = -1 def sentinel(): base.min() time.sleep(1) base.mid() time.sleep(1) base.max() time.sleep(1) base.mid()
import gpiozero
from time import sleep
SERVO_1 = gpiozero.Servo(25)
angle = 50
interval = 0.5
print("""
1) This script will prompt you for servo angles. (0%-100%)
2) Then it will set the servo and detach it.
3) This repeats while the value you enter is below 100.
4) 101 starts a sweeping movement with increasing angles.
5) 102 starts a slow and gradual turn from 0 to 100%.
6) 103 is a button press movement.
""")
"""
NOTES
SERVO_1 shall to -99 (full open) to +99 (full closed)
SERVO_2 is shut at 88 and full open at -88
"""
# FUNCTIONS
def servo_sequence(list):
for a in list:
print(a)
SERVO_1.value = a / 100
sleep(interval)
# SCRIPT
from time import sleep
app = Flask(__name__)
devices = {
'motor1': {
'object': gpiozero.Motor(22, 27),
'name': 'motor1',
'state': 'stopped'
},
'motor2': {
'object': gpiozero.Motor(23, 24),
'name': 'motor2',
'state': 'stopped'
},
'servo': {
'object': gpiozero.Servo(18),
'name': 'servo',
'state': 'stopped'
},
'led': {
'object': gpiozero.DigitalOutputDevice(25),
'name': 'led',
'state': 'off'
}
}
@app.route("/")
def main():
# Put data in templateData
templateData = {'devices': devices}
self.multiplier = -1
else:
self.multiplier = 1
while not (self.parts[part_name].value > value - self.sensitivity
and self.parts[part_name].value < value + self.sensitivity):
self.parts[part_name].value = self.parts[
part_name].value + self.multiplier * self.STEP
print(self.parts[part_name].value)
time.sleep(speed)
self.has_moved = part_name
return 0
#variabili globali
base = gpiozero.Servo(4, pin_factory=PiGPIOFactory())
gripper = gpiozero.Servo(10, pin_factory=PiGPIOFactory())
elbow = gpiozero.Servo(17, pin_factory=PiGPIOFactory())
shoulder = gpiozero.Servo(22, pin_factory=PiGPIOFactory())
arm = Arm(base, gripper, elbow, shoulder)
def on_connect(client, userdata, flags, rc):
print("Connesso al broker con codice {}".format(str(rc)))
#mi iscrivo al topic del braccio
client.subscribe("meArm")
print("Iscritto al topic meArm")
import gpiozero from time import sleep print "Declare motors" # Declaring motors on GPIOs 22, 27, 23 and 24. These are for moving f/b. motor1 = gpiozero.Motor(22, 27) motor2 = gpiozero.Motor(23, 24) # Declaring servomotor on GPIO 18. This will give direction. servo = gpiozero.Servo(18) print "First routine" # First routine. Robot move forward. servo.mid() motor1.forward(1) # Max speed motor2.forward(1) # Max speed print "About to sleep" sleep(5) print "Stopping motors" motor1.stop() motor2.stop() print "Finish"
def create_servo(pin, servo_type):
if servo_type == 'gpiozero':
return gpiozero.Servo(pin)
else:
return parts.servo.Servo(pin)
