def camController():
global txCamData, camAngle, headAngle
camPin = 4
headPin = 17
print('camController Started')
camServo = AngularServo(camPin,
min_angle=0,
max_angle=180,
min_pulse_width=(0.5 / 1000),
max_pulse_width=(2.3 / 1000),
frame_width=20 / 1000)
headServo = AngularServo(headPin,
min_angle=-90,
max_angle=90,
min_pulse_width=(0.5 / 1000),
max_pulse_width=(2.3 / 1000),
frame_width=20 / 1000)
camServo.angle = 90
headServo.angle = 0
time.sleep(1)
while True:
txCamData = 0
#time.sleep(0.500)
camAngle = int(rxCamData % 1000) #end digits xxxabc abc is data
headAngle = int(rxCamData / 1000) #begin digits abcxxx
#if rxCamData:
#print("rxCamData: %d" % rxCamData)
camServo.angle = camAngle
headServo.angle = headAngle
def __init__(self):
self.__ServoVertical = AngularServo(5, min_angle=0, max_angle=180, min_pulse_width=.000553, max_pulse_width=.002425, frame_width=.02)
self.__ServoHorizontal = AngularServo(6, min_angle=0, max_angle=180, min_pulse_width=.000553, max_pulse_width=.002425, frame_width=.02)
self.__last_known_vert_loc = 0
self.__last_known_hori_loc = 0
#self.default_position()
self.__ServoVertical.angle = None
self.__ServoHorizontal.angle = None
def __init__(self, pin, inital_angle=0, reverse=False):
self.servo = None
self.current_angle = inital_angle
angle = self.current_angle - 90
if reverse:
self.servo = AngularServo(pin, angle, min_angle=90, max_angle=-90)
else:
self.servo = AngularServo(pin, angle)
def __init__(self):
self.servo_de = AngularServo(self.porta_de,
min_angle=self.min_de,
max_angle=self.max_de)
self.servo_da = AngularServo(self.porta_da,
min_angle=self.min_da,
max_angle=self.max_da)
self.servo_dr = AngularServo(self.porta_dr,
min_angle=self.min_dr,
max_angle=self.max_dr)
def gpioInit(self):
self.vrChannel = MCP3008(channel=7)
self.distanceSensor = DistanceSensor(23, 24)
self.servo = AngularServo(18, min_angle=-45, max_angle=45)
self.servo.angle = 0.0
Timer(1, self.gpioAutoUpdate).start()
def __init__(self, codigoDesactivacion):
self.activo = True
self.DIR_BASE = os.path.dirname(os.path.abspath(__file__))
self.rutaLogs = os.path.join(self.DIR_BASE, 'logs')
self.nombreArchivo = 'bitacora_accesso.txt'
self.rutaArchivo = os.path.join(self.rutaLogs, self.nombreArchivo)
self.crearArchivo()
self.estadoServo = True
self.estadoServo2 = True
self.anguloDefault = 90
self.angulo2Default = 90
self.gpioServoPin = 17
self.gpioServo2Pin = 20
self.codigoDesactivacion = codigoDesactivacion
self.servo = AngularServo(self.gpioServoPin)
self.servo2 = AngularServo(self.gpioServo2Pin)
def main():
parser = argparse.ArgumentParser(
description='Example application for displaying a dial indicator for '
'what object is seen')
parser.add_argument(
'--output_overlay',
default=True,
type=bool,
help='Should the visual overlay be generated')
parser.add_argument(
'--button_enabled',
default=True,
type=bool,
help='Should the button be monitored')
parser.add_argument(
'--button_active',
default=False,
type=bool,
help='Should the button start out active (true) or only be active once '
'pressed (false)')
flags = parser.parse_args()
load_model = time.time()
category_count = len(category_mapper.get_categories())
button = AutoButton(flags.button_active, flags.button_enabled)
for category in category_mapper.get_categories():
print('Category[%d]: %s' % (category_mapper.get_category_index(category),
category))
with picamera.PiCamera() as camera:
camera.resolution = (1640, 1232)
camera.start_preview()
overlay = OverlayManager(
camera) if flags.output_overlay else DummyOverlayManager()
servo = AngularServo(PIN_A, min_pulse_width=.0005, max_pulse_width=.0019)
with CameraInference(image_classification.model()) as classifier:
print('Load Model %f' % (time.time() - load_model))
for result in classifier.run():
if not button.on():
overlay.clear()
servo.angle = -90
continue
classes = image_classification.get_classes(result)
probs = [0] * (category_count + 1)
result_categories = []
for label, score in classes:
category = category_mapper.get_category(label) or 'Other'
probs[category_mapper.get_category_index(category) + 1] += score
result_categories.append(category)
overlay.update(classes, result_categories)
max_prob = max(probs)
best_category = probs.index(max_prob)
if best_category == 0 and max_prob > .5:
servo.angle = -90
elif best_category != 0:
servo.angle = -90 + (180 * best_category) / category_count
print('category: %d - %s' %
(best_category,
category_mapper.get_categories()[best_category - 1]))
def update_jaw(self):
self.jaw = AngularServo(c.JAW_PIN,
min_angle=c.MIN_ANGLE,
max_angle=c.MAX_ANGLE,
initial_angle=None,
min_pulse_width=c.SERVO_MIN / (1 * 10**6),
max_pulse_width=c.SERVO_MAX / (1 * 10**6))
def main():
# now just write the code you would use on a real Raspberry Pi
from time import sleep
from gpiozero import AngularServo, Button, LED
servo1 = AngularServo(17, min_angle=-90, max_angle=90)
# possible_status = ['Rain', 'Clear', 'Clouds', 'Drizzle']
#LED for showig activ city
led_Krk = LED(22)
led_Stk = LED(21)
active_city = "Krakow"
led_Krk.on()
button1 = Button(11)
button2 = Button(12)
button1.when_pressed = lambda: button1_pressed(active_city, led_Krk,
led_Stk)
button2.when_pressed = lambda: button2_pressed(active_city, led_Krk,
led_Stk)
while True:
print("Active city: ", active_city)
servo1.angle = status_to_angle(import_weather(active_city))
sleep(3)
def __init__(self):
self.p = pyaudio.PyAudio()
self.jaw = AngularServo(c.JAW_PIN, min_angle=c.MIN_ANGLE,
max_angle=c.MAX_ANGLE, initial_angle=None,
min_pulse_width=c.SERVO_MIN/(1*10**6),
max_pulse_width=c.SERVO_MAX/(1*10**6))
self.bp = BPFilter()
def main():
# now just write the code you would use on a real Raspberry Pi
from time import sleep
from gpiozero import AngularServo, LED, Button
from weather import Weather
weather = Weather()
def button1_pressed():
city_weather = weather.get_next_weather()
print(city_weather)
servo1.angle = convert_deg_temp(city_weather['temp'])
def button2_pressed():
print("button 2 pressed!")
button1 = Button(11)
button1.when_pressed = button1_pressed
button2 = Button(12)
button2.when_pressed = button2_pressed
servo1 = AngularServo(17, min_angle=-90, max_angle=90)
servo1.angle = convert_deg_temp(weather.get_next_weather()['temp'])
while True:
pass
def slider_angle(slider_num):
n = slider_num
servo1 = AngularServo(gpio20,
min_pulse_width=minPW,
max_pulse_width=maxPW,
initial_angle=0)
servo1.angle = int(n)
print(n)
sleep(.5)
def slider2_angle(slider2_num):
n2 = slider2_num
servo2 = AngularServo(gpio21,
min_pulse_width=minPW,
max_pulse_width=maxPW,
initial_angle=0)
servo2.angle = int(n2)
print(n2)
sleep(.5)
def Turn_Horizontal(slider_value):
n = int(slider_value)
servo_Horizontal = AngularServo(17,
min_angle=-90,
max_angle=90,
min_pulse_width=minPWM,
max_pulse_width=maxPWM)
servo_Horizontal.angle = n
sleep(2)
def slider_change2(slider_value): #slider value for motor 2
textbox.value = slider_value
print(slider_value)
servo2 = AngularServo(Servo2,
min_pulse_width=minPulseWidth,
max_pulse_width=maxPulseWidth,
initial_angle=0,
min_angle=-0,
max_angle=90)
servo2.angle = int(slider_value)
def __init__(self):
self.leftArmPin = 4
self.leftArmMin = -180
self.leftArmMax = -100
self.rightArmPin = 17
self.rightArmMin = -180
self.rightArmMax = 0
self.swivelPin = 27
self.swivelArmMin = -180
self.swivelArmMax = 180
self.leftServo = AngularServo(self.leftArmPin, min_angle=-180, max_angle=180)
self.rightServo = AngularServo(self.rightArmPin, min_angle=-180, max_angle=180)
self.swivelServo = AngularServo(self.swivelPin, min_angle=-180, max_angle=180)
self.increment = 10
def __init__(self, pin: int, angMin: float = -90, angMax: float = 90):
self.pin = pin
if environ.get('development') == '1':
# This creates a mock servo, for simulating controls and testing,
# without having to use the Raspberry Pi every time
self.s = DevAngularServo(pin, initial_angle=0)
else:
self.s = AngularServo(pin, initial_angle=0)
self.angMax = angMax
self.angMin = angMin
def slider_change2(slider2_value):
text2.value = slider2_value
servo2 = AngularServo(Servo2,
min_pulse_width=minpw,
max_pulse_width=maxpw,
initial_angle=0,
min_angle=0,
max_angle=180)
servo2.angle = int(slider2_value)
time.sleep(.25)
def slider_change1(slider1_value):
text1.value = slider1_value
servo1 = AngularServo(Servo1,
min_pulse_width=minpw,
max_pulse_width=maxpw,
initial_angle=0,
min_angle=0,
max_angle=180)
servo1.angle = int(slider1_value)
time.sleep(.25)
def cam_action(msg):
servo = AngularServo(config.CAMSERVO_TILT,
min_pulse_width=0.2/1000,
max_pulse_width=1.8/1000,
frame_width=20/1000,
)
angle = json.loads(msg["data"])["angle"]
if angle <= 90 and angle >= -90:
servo.angle = angle
time.sleep(1)
def __init__(self, pin, min_angle=-90, max_angle=90, default_angle=0):
super().__init__()
self.pin = pin
self.min_angle = min_angle
self.max_angle = max_angle
self.resource = AngularServo(pin,
min_angle=min_angle,
max_angle=max_angle)
self.resource.angle = default_angle
def main():
from gpiozero import MCP3002, AngularServo
from time import sleep
pot1 = MCP3002(1, max_voltage=5, clock_pin=11, mosi_pin=10, miso_pin=9, select_pin=8)
pot2 = MCP3002(1, max_voltage=5, clock_pin=15, mosi_pin=14, miso_pin=13, select_pin=12)
servo1 = AngularServo(17, min_angle=0, max_angle=159)
servo1.angle = 0
servo2 = AngularServo(18, min_angle=-60, max_angle=240)
servo2.angle = -60
while True:
print(f"pot1: value = {pot1.value:0.2f}\tvoltage = {pot1.voltage:0.2f}\traw value = {pot1.raw_value:0.2f}")
servo1.angle = 159 * pot1.value
print(f"pot2: value = {pot2.value:0.2f}\tvoltage = {pot2.voltage:0.2f}\traw value = {pot2.raw_value:0.2f}")
servo2.angle = -60 + 300 * pot2.value
sleep(0.1)
def setup(pins=None):
''' setup servos '''
gpio = pins or PINS
servos = []
for i, val in enumerate(gpio):
servos.append(
AngularServo(val,
initial_angle=CAL[i],
min_angle=MIN[i],
max_angle=MAX[i]))
return servos
def slidervalchange2(slider_val):
textbox.value = slider_val
print(slider_val)
servo2 = AngularServo(20,
min_pulse_width=minPW,
max_pulse_width=maxPW,
initial_angle=0,
min_angle=-90,
max_angle=90)
servo2.angle = int(slider_val)
time.sleep(0.4)
def main():
from time import sleep
from gpiozero import AngularServo, Button
servo1 = AngularServo(17, min_angle=-90, max_angle=90)
button1 = Button(12)
button1.when_activated = change_location
while True:
servo1.angle = set_angle(current_location)
sleep(0.1)
def __init__(self, controller_connected):
self.front_right_wheel = Servo(16)
self.front_left_wheel = Servo(19)
self.back_right_wheel = Servo(20)
self.back_left_wheel = Servo(26)
self.steering_servo = AngularServo(21, min_angle=-45, max_angle=45)
self.speed = -1
self.limiter = -1
self.regulator = threading.Event()
self.regulator_thread = threading.Thread(target=self.regulator_run, args=(lambda: controller_connected,))
self.regulator_thread.start()
self.regulator_thread.join()
def main():
from time import sleep
from gpiozero import AngularServo, Button
servo1 = AngularServo(17, min_angle=-90, max_angle=90)
button_upper = Button(12)
change_location()
button_upper.when_activated = change_location
while True:
servo1.angle = get_servo_angle(location)
sleep(0.1)
def __init__(self):
self._TRUEZERO = 5
self.throttleScalingFactor = 0.25
IO.setwarnings(False)
IO.setmode(IO.BCM)
IO.setup(12, IO.OUT)
IO.setup(23, IO.OUT, initial=1)
self._p = IO.PWM(12, 500)
self._p.start(0)
self._servo = AngularServo(13, min_angle=-90, max_angle=90)
self._servo.angle = self._TRUEZERO
def __init__(self):
# servo object to control
self.revolver = AngularServo(self.SERVO_PIN, min_angle=0, max_angle=180)
# array of discrete possible positions
self.positions = list()
# boolean variable to tell if the direction is increasing or not
self.increasing = True
# current state of the IR sensor
self.sensor_state = 0
# last state of the IR sensor
self.last_state = 0
# cycle counter for the state change of the breakbeam sensor
self.cycle = 0
# balance of pellets to dispense
self.pellet_balance = 0
# TODO: implement empty detection
# boolean variable to tell if the dispenser is empty
self.empty = False
self.closest = 0
# todo: fix automatic angle piking
# takes the number of the furthest position, angle change per movement in degrees,
# and a pointer to an array to returns the positions in
# returns a modified version of the positions array populated with the discrete possible positions
# def find_positions(): # This used to be a function, but it was only ever used once
# self.positions.append(0.)
# counter = 1
# while (counter * self.MOVEMENT_AMOUNT) < self.OPERATING_RANGE:
# self.positions.append((self.positions[counter-1] + self.MOVEMENT_AMOUNT))
# counter += 1
# optimal positions: 15, 65, 115, 165
self.positions = (15., 65., 115., 165.)
# self.closest = self.find_closest(self.revolver.angle)
print(self.positions)
# current discrete position of the revolver set to the center position
self.pos = int(len(self.positions)/2.) # self.find_closest(self.revolver.angle)
# adjust to the closest acceptable angle
self.revolver.angle = self.positions[self.pos]
def main():
# Now just write the code you would use on a real Raspberry Pi
from time import sleep
from gpiozero import AngularServo
servo1 = AngularServo(17, min_angle=-90, max_angle=90)
servo1.angle = -90
while True:
for x in range(-90, 90):
servo1.angle = x
sleep(0.1)
