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)