async def motor():
global motorON
global motor
global previousMotorON
# Adjust the pulse values to set rotation range
min_pulse = 0.000544 # Library default = 1/1000
max_pulse = 0.0024 # Library default = 2/1000
# Initial servo position
pos = 1
test = 0
servo = Servo(17, pos, min_pulse, max_pulse, 20/1000, None)
while True:
await asyncio.sleep(0.2)
if motorON == True:
pos=pos*(-1)
servo.value=pos
await asyncio.sleep(2)
else :
#put back in original position
servo.value=0
#detach the motor to avoid glitches and save energy
servo.detach()
previousMotorON = False
def FaceForward(self):
s = Servo(self.pin,
min_pulse_width=0.5 / 1000,
max_pulse_width=10 / 1000,
frame_width=20 / 1000)
s.max()
time.sleep(0.3)
s.detach()
def FaceRight(self):
s = Servo(self.pin,
min_pulse_width=1.1 / 1000,
max_pulse_width=10 / 1000,
frame_width=20 / 1000)
s.min()
time.sleep(0.3)
s.detach()
def FaceLeft(self):
s = Servo(self.pin,
min_pulse_width=1 / 1000,
max_pulse_width=10.6 / 1000,
frame_width=20 / 1000)
s.max()
time.sleep(0.3)
s.detach()
class PowerSelector:
pulse = FS5106S
_min_level = 1
_max_level = 9
_min_pos = -1.0
_max_pos = 1.0
_delta = (_max_pos - _min_pos) / (_max_level - _min_level)
_level = (_max_level - _min_level + 1) // 2
def __init__(self, pin):
self._servo = Servo(pin,
self._pos,
self.pulse[0],
self.pulse[1],
20 / 1000,
pin_factory=factory)
self.set_level(self._level)
@property
def _pos(self):
# level 1 = 1
# level 9 = -1
# the servo is installed reversed,
# so -1 - is max power, 1 - is min
pos = self._max_pos - \
(self._level - self._min_level) * self._delta
if pos > self._max_pos:
pos = self._max_pos
if pos < self._min_pos:
pos = self._min_pos
return pos
def set_level(self, new_level):
if new_level < self._min_level:
new_level = self._min_level
if new_level > self._max_level:
new_level = self._max_level
self._level = new_level
logger.info(f"Setting power level to {new_level}")
pos = self._pos
logger.debug(f"Servo pos is set to {pos}")
self._servo.value = self._pos
sleep(3)
self._servo.detach()
def detach(self):
self._servo.detach()
def feed(self, feed_size):
if not is_gpio_capable:
logging.getLogger('petfeedd').info(
"This device is not GPIO capable. Simulating a feed.")
return
feed_size_time = float(
self.config["gpio"]["servo_feed_time"]) * float(feed_size)
servo = Servo(int(self.config["gpio"]["servo_pin"]))
servo.max()
time.sleep(feed_size_time)
servo.detach()
class Motor(Servo):
def __init__(self, servoPin):
"Initializes the servo and has basic drive functions"
self.servo = Servo(servoPin)
def forward(self):
"Function that drives the servos forward"
self.servo.max()
time.sleep(0.05)
def backward(self):
"Function that drives the servos backward"
self.servo.min()
time.sleep(0.05)
def stop(self):
"Stops motor movement"
self.servo.detach()
class WeatherDashboard:
servo_pin = 17
led_pin = 14
def __init__(self, servo_position=0, led_status=0):
self.servo = Servo(self.servo_pin)
self.led = LED(self.led_pin)
self.move_servo(servo_position)
self.set_led_status(led_status)
def move_servo(self, servo_position=0):
self.servo.value = self.convert_percentage_to_integer(servo_position)
self.servo.detach()
def set_led_status(self, led_status=0):
if led_status == 0:
self.led.off()
elif led_status == 1:
self.led.on()
else:
self.led.blink()
def convert_percentage_to_integer(self, percentage_amount):
return (percentage_amount * .02) - 1
from time import sleep
from slow import sweep
#pins 23 and 24 connect to servos w signal wire
tilt = Servo(24)
pan = Servo(23)
l_led = LED(22)
r_led = LED(17)
#initial tilt to minimum pos (horizontal)
#inital pan to middle pos (straight)
tilt.value = -1
pan.value = 0
#after any position adjustment allow small wait for servo to respond before detachment
sleep(0.3)
tilt.detach()
pan.detach()
sleep(1)
print('Left LED On')
l_led.on()
sleep(2)
print('Left LED Off')
l_led.off()
sleep(1)
print('Right LED On')
r_led.on()
sleep(2)
print('Right LED Off')
r_led.off()
sleep(1)
print(3)
def gen_graph():
volumes = []
times = []
for i in range(25):
volumes.append(sample_half())
times.append(time())
print(volumes[-1])
if volumes[-1] > 0.04:
print('NOISE')
plt.plot(times, volumes)
plt.show()
s = Servo(17)
s.detach()
def go():
multiplier = 10
while True:
vol = sample_half()
if vol < 0.01 or vol > 0.1:
s.detach()
else:
s.value = vol * multiplier
multiplier = -multiplier
sleep(0.2)
s.mid()
print(vol)
class ServoDevice:
servo_pin = 17
def __init__(self, servo_position=-1):
self.servo = Servo(self.servo_pin)
# self.move_servo(servo_position)
def validator(self, pPos):
#print("run validator")
if (pPos < -1):
print("Value is below minimum range for servo!")
print(pPos)
pPos = -1
# return pPos
elif (pPos > 1):
print("Value is above maximum range for servo!")
print(pPos)
pPos = 1
return pPos
def move_servo(self, servo_position):
#self.servo.value=self.convert_percentage_to_integer(servo_position)
servo_position = self.validator(servo_position)
self.servo.value = servo_position
def convert_percentage_to_integer(self, percentage_amount):
return (percentage_amount * 0.02) - 1
def calculatePosFromTemp(self, data):
maxPos = -1 #value is in degrees
minPos = 1
totalRange = abs(maxPos) + abs(minPos)
maxTemp = 50 # value is in Celcius
conversionVal = totalRange / maxTemp
currentTemp = data
nextPos = 0
if (float(currentTemp) > 25):
nextPos = minPos
elif (float(currentTemp) < 18.5):
nextPos = maxPos
else:
nextPos = float(currentTemp) * conversionVal
print(nextPos)
self.move_servo(nextPos)
time.sleep(1)
self.servo.detach()
return nextPos
def sweep_motor(self):
pos = 0
speedRateLimiter = .02
#(pos = 0 pos <= 171 pos += 1)
for x in arange(-1, 1, 0.05):
pos = x
self.move_servo(pos)
time.sleep(speedRateLimiter)
#(pos = 172 pos >= 0 pos -= 1)
for x in arange(1, -1, -0.05):
pos = x
self.move_servo(pos)
time.sleep(speedRateLimiter)
def test_range_of_motion(self):
self.sweep_motor()
self.servo.max()
time.sleep(1)
self.servo.mid()
time.sleep(1)
self.servo.min()
time.sleep(1)
self.servo.detach()
def test_calculation(self, data):
newPos = servo_device.calculatePosFromTemp(data)
self.move_servo(newPos)
time.sleep(1)
self.servo.detach()
from gpiozero import Servo
from time import sleep
servo = Servo(17)
counter = 0
while counter < 8:
servo.value = 0.25
sleep(1)
counter += 1
if counter >= 8:
servo.detach()
sleep(86392)
counter = 0
continue
radio2.printDetails()
radio2.startListening()
#setup the servos
myCorrection = 0.045
maxPW = (2.0 + myCorrection) / 1000
minPW = (1.0 - myCorrection) / 1000
rudderServo = Servo(12, min_pulse_width=minPW, max_pulse_width=maxPW)
elevatorServo = Servo(13, min_pulse_width=minPW, max_pulse_width=maxPW)
rudderServoVal = 0.0
elevatorServoVal = 0.0
rudderServo.detach()
elevatorServo.detach()
#delay for allowing servos time to move
delay = 0.1
while True:
pipe = [0]
while not radio2.available(pipe):
time.sleep(10000 / 1000000.0)
recv_buffer = []
radio2.read(recv_buffer, radio2.getDynamicPayloadSize())
#print ("Received:") ,
#print (recv_buffer)
class _Rover:
def __init__(self):
self.right = Servo(12)
self.right.detach()
self.left = Servo(13)
self.left.detach()
if (x == "+"):
pwm0.value += 0.01
pwm1.value += 0.01
print(pwm0.value, pwm1.value, sep=" // ")
elif (x == "-"):
pwm0.value -= 0.01
pwm1.value -= 0.01
print(pwm0.value, pwm1.value, sep=" // ")
elif (x == "value"):
print(pwm0.value, pwm1.value, sep=" // ")
elif (x == "pw"):
print(pwm0.pulse_width, pwm1.pulse_width, sep=" // ")
elif (x == "fw"):
print(pwm0.frame_width, pwm1.frame_width, sep=" // ")
elif (x == "isactive"):
print(pwm0.is_active, pwm1.is_active, sep=" // ")
elif (x == "min"):
pwm0.min() # actual min seems to be -0.27
pwm1.min() # actual min seems to be -0.27
elif (x == "mid"):
pwm0.mid()
pwm1.mid()
elif (x == "max"):
pwm0.max()
pwm1.max()
elif (x == "detach" or x == "stop"):
pwm0.detach()
pwm1.detach()
else:
pwm0.value = float(x)
pwm1.value = float(x)
tiltToPercentage(x)
time.sleep(0.1)
for x in range(100, -5, -5):
panToPercentage(x)
time.sleep(0.1)
tiltToPercentage(50)
panToPercentage(50)
time.sleep(0.2)
pan_servo.detach()
tilt_servo.detach()
global tilt_servo
global pan_servo
if __name__ == '__main__':
tilt_servo = Servo(TILT_PIN, min_pulse_width=PULSE_MIN, max_pulse_width=PULSE_MAX, frame_width=PULSE_WIDTH)
pan_servo = Servo(PAN_PIN, min_pulse_width=PULSE_MIN, max_pulse_width=PULSE_MAX, frame_width=PULSE_WIDTH)
logging.info("Starting demo loop")
while True:
try:
demo()
time.sleep(10)
pan_servo.detach()
tilt_servo.detach()
except KeyboardInterrupt:
logging.info("interrupted, exiting")
break
pan_servo.detach()
tilt_servo.detach()
logging.debug("Done")
from gpiozero import Servo
DIRECTION_SERVO_PIN = 2
directionServo = Servo(DIRECTION_SERVO_PIN)
directionServo.mid()
running = True
while running:
response = input("Enter comand: ")
if response.startswith("exit"):
running = False
else:
try:
value = float(response)
directionServo.value = value
print("Servo {}".format(value))
except:
print("Your expression doesn't match")
print("Closing application ...")
directionServo.detach()
exit(0)
