def __init__(self, driver, status_led, black_track=True): self._driver = driver self._status_led = status_led self._black_track = black_track self._sensor_left = LineSensor(pin=PIN_LEFT_LINE_SENSOR, pull_up=lts.IS_PULL_UP) self._sensor_right = LineSensor(pin=PIN_RIGHT_LINE_SENSOR, pull_up=lts.IS_PULL_UP) # These callback functions are called the first time that one of the # relative events occurs. self._callbacks = { self._State.BOTH_ON_TRACK: self._both_on_track_callback, self._State.LEFT_ON_TRACK: self._left_on_track_callback, self._State.RIGHT_ON_TRACK: self._right_on_track_callback, self._State.NONE_ON_TRACK: self._none_on_track_callback, } # Assume the robot is well-centered on the track. self._state = self._State.NONE_ON_TRACK self._status_led.set(ls.Status.AUTOPILOT) _logger.info('{} initialized'.format(self.__class__.__name__))
def __init__(self, motorhat_addr=0x6f, drive_enabled=True): # Setup the motorhat with the passed in address self._mh = Raspi_MotorHAT(addr=motorhat_addr) # get local variable for each motor self.left_motor = self._mh.getMotor(1) self.right_motor = self._mh.getMotor(2) self.drive_enabled = drive_enabled # ensure the motors get stopped when the code exits atexit.register(self.stop_all) # Setup the line sensors self.left_line_sensor = LineSensor(23, queue_len=3, pull_up=True) self.right_line_sensor = LineSensor(16, queue_len=3, pull_up=True) # Setup The Distance Sensors self.left_distance_sensor = DistanceSensor(17, 27) self.right_distance_sensor = DistanceSensor(5, 6) # Setup the Encoders EncoderCounter.set_constants(self.wheel_diameter_mm, self.ticks_per_revolution) self.left_encoder = EncoderCounter(4) self.right_encoder = EncoderCounter(26) # Setup the Leds self.leds = leds_8_apa102c.Leds() # Set up servo motors for pan and tilt. self.servos = Servos(addr=motorhat_addr)
def __init__(self, motorhat_addr=0x6f): self._mh = Raspi_MotorHAT(addr=motorhat_addr) self.left_motor = self._mh.getMotor(1) self.right_motor = self._mh.getMotor(2) atexit.register(self.stop_all) self.left_line_sensor = LineSensor(23, pull_up=True) self.right_line_sensor = LineSensor(16, pull_up=True)
def __init__(self): self.sensor = [0, 0, 0, 0, 0] try: self.sensor[0] = LineSensor(5) self.sensor[1] = LineSensor(6) self.sensor[2] = LineSensor(13) self.sensor[3] = LineSensor(19) self.sensor[4] = LineSensor(26) except: print("Sensores não conectados corretamente")
async def __aenter__(self): await self.lock.acquire() self.lmotor = Motor(*self.conf['motor']['left']) self.rmotor = Motor(*self.conf['motor']['right']) # self.reset_servos() self.reset_motors() self.lir = LineSensor(self.conf['ir']['left'], queue_len=3, sample_rate=10, pull_up=True) self.rir = LineSensor(self.conf['ir']['right'], queue_len=3, sample_rate=10, pull_up=True) sonar_cfg = self.conf['sonar'] self.sonar = DistanceSensor(trigger=sonar_cfg['trigger'], echo=sonar_cfg['echo'], max_distance=sonar_cfg['max'], threshold_distance=sonar_cfg['threshold'], queue_len=5, partial=True) self._sensor_event_queue = None self._button_last_press_time = 0 def cb(ev, obj, attr): return lambda: self._sensor_event_queue and self.event_loop.call_soon_threadsafe( self._sensor_event_queue.put_nowait, (ev, getattr(obj, attr))) def button_press_cb(): if self._sensor_event_queue: now = time.time() if now - self._button_last_press_time <= self._double_press_max_interval: ev = 'double_pressed' else: ev = 'pressed' self.event_loop.call_soon_threadsafe( self._sensor_event_queue.put_nowait, (ev, True)) self._button_last_press_time = now self.lir.when_line = self.lir.when_no_line = cb( 'lir', self.lir, 'value') self.rir.when_line = self.rir.when_no_line = cb( 'rir', self.rir, 'value') self.button.hold_time = 1 self.button.when_pressed = button_press_cb self.button.when_released = cb('pressed', self.button, 'is_pressed') self.button.when_held = cb('held', self.button, 'is_held') self.sonar.when_in_range = cb('in_range', self.sonar, 'distance') self.sonar.when_out_of_range = cb('out_of_range', self.sonar, 'distance') self.screen.fill(0) self.screen_backlight.fraction = .05 return self
def __init__(self, remote_address): # set PINs on BOARD log.debug("Initializing Track...") log.debug("> track 1: " + str(_conf['track_1_pin'])) log.debug("> track 2: " + str(_conf['track_2_pin'])) # using LineSensor rem_pi = PiGPIOFactory(host=remote_address) self.track1 = LineSensor(_conf['track_1_pin'], pin_factory=rem_pi) self.track2 = LineSensor(_conf['track_2_pin'], pin_factory=rem_pi) log.debug("...init done!")
def __init__(self, motorhat_addr=0x6f): # Setup the motorhat with the passed in address self._mh = Raspi_MotorHAT(addr=motorhat_addr) # get local variable for each motor self.left_motor = self._mh.getMotor(1) self.right_motor = self._mh.getMotor(2) # ensure the motors get stopped when the code exits atexit.register(self.stop_all) # Setup the line sensors self.left_line_sensor = LineSensor(23, queue_len=3, pull_up=True) self.right_line_sensor = LineSensor(16, queue_len=3, pull_up=True)
def __init__(self, motorhat_addr=0x6f): self._mh = Raspi_MotorHAT(addr=motorhat_addr) self.left_motor = self._mh.getMotor(1) self.right_motor = self._mh.getMotor(2) atexit.register(self.stop_motors) # Setup the line sensors self.right_line_sensor = LineSensor(23, queue_len=3, pull_up=True) self.left_line_sensor = LineSensor(16, queue_len=3, pull_up=True) self.right_line_sensor_stuck = "" self.left_line_sensor_stuck = "" self.servos = Servos(addr=motorhat_addr)
def __init__(self, config: dict): super().__init__("linesensors") self.sensors = {} for name, sensor_config in config['linesensors'].items(): sensor = LineSensor(sensor_config['pin']) sensor.when_line = sensor.when_no_line = self._when_line_changed self.sensors[name] = sensor
def __init__(self,mh_addr=0x60): #使用给定的地址设置motorHAT self._mh=MotorHAT(addr=mh_addr) #设置两个马达 self.left_motor=self._mh.getMotor(1) self.right_motor=self._mh.getMotor(2) # recommended for auto-disabling motors on shutdown! atexit.register(self.stop_all) #设置两个巡线传感器 self.left_line_sensor=LineSensor(23) self.right_line_sensor=LineSensor(16) #设置全彩LED self.leds=neopixel.NeoPixel(pixel_pin, num_pixels, brightness=0.2, auto_write=False, pixel_order=ORDER)
class RoPiTrack: # initialize def __init__(self, remote_address): # set PINs on BOARD log.debug("Initializing Track...") log.debug("> track 1: " + str(_conf['track_1_pin'])) log.debug("> track 2: " + str(_conf['track_2_pin'])) # using LineSensor rem_pi = PiGPIOFactory(host=remote_address) self.track1 = LineSensor(_conf['track_1_pin'], pin_factory=rem_pi) self.track2 = LineSensor(_conf['track_2_pin'], pin_factory=rem_pi) log.debug("...init done!") # are tracks on line? def is_on_line(self): track1 = self.track1.value == _conf['color'] track2 = self.track2.value == _conf['color'] log.debug("> is on line ?" + str(track1 and track2)) return track1 and track2 # is track1 on line? def track1_on_line(self): track1 = self.track1.value == _conf['color'] log.debug("> is track 1 on line?" + str(track1)) return track1 # is track2 on line? def track2_on_line(self): track2 = self.track2.value == _conf['color'] log.debug("> is track 2 on line?" + str(track2)) return track2 # terminate def terminate(self): log.debug("Track termination...") self.track1.close() self.track2.close()
def main(): common.init_logging(logger) parser = common.init_argparser("Data collection for honey.fitness") parser.add_argument("--gpio-pin", default=4, help="Sensor pin number") args = parser.parse_args() data_path = common.init_local_data_path(args.data_path) logger.info(f"Using {data_path} for local data storage") minute_timer = RepeatingTimer(60, on_save, args=(data_path, )) minute_timer.start() sensor = LineSensor(args.gpio_pin) sensor.when_line = on_magnet logger.info(f"Monitoring GPIO {args.gpio_pin} for rotation counts") logger.info("Starting monitor") try: signal.pause() except KeyboardInterrupt: pass minute_timer.cancel() logger.info("Stopped monitor")
from gpiozero import LED, LineSensor from time import sleep red = LED(17) lsensor = LineSensor(23) rsensor = LineSensor(16) lsensor.when_line = lambda: red.on() lsensor.when_no_line = lambda: red.off() while True: sleep(0.02)
lcd_rs = DigitalInOut(board.D25) lcd_en = DigitalInOut(board.D24) lcd_d7 = DigitalInOut(board.D22) lcd_d6 = DigitalInOut(board.D18) lcd_d5 = DigitalInOut(board.D17) lcd_d4 = DigitalInOut(board.D23) # Initialize button button = Button(button_pin) # Initialize servo factory = PiGPIOFactory() servo = Servo(pin=servo_pin, initial_value=1, pin_factory=factory) # Initialize ir ir = LineSensor(ir_pin) # Initialize lcd lcd_columns = 16 lcd_rows = 2 lcd = characterlcd.Character_LCD_Mono(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7, lcd_columns, lcd_rows) # Global variables normal_mode = True count = 0 # Function to display lcd message (2nd line) def set_lcd(message): lcd.clear()
# CamJam EduKit 3 - Robotics # Line Follower GPIO Zero version (untested) # by Neil Bizzell (@PiVangelist) from gpiozero import LineSensor, CamJamKitRobot # import LineSensor and CamJamKit Robot objects from GPIO Zero library from signal import pause # import pause from signal library #define sensor as instance of LineSensor Class and define pin as Pin 25 sensor = LineSensor(25) #Define robot as instance of CamJamKit Robot Class robot = CamJamKitRobot() def left(): robot.value(1, 0) def right(): robot.value(0, 1) sensor.when_line = left() sensor.when_no_line = right() pause()
from gpiozero import LineSensor from signal import pause from time import sleep onLine = False sensor = LineSensor(4) sensor.when_line = lambda: getState(True) sensor.when_no_line = lambda: getState(False) def getState(data): global onLine onLine = data if data: print("data line") else: print("data not_line") i = 0 while True: i+=1 if onLine: print("line") else: print("not_line") print ("%d times " % i) sleep(1)
from gpiozero import LineSensor, Robot from time import sleep, time robot = Robot(left=(7, 8), right=(9, 10)) line = LineSensor(18) speed = 0.8 def on_line(): print('running on') robot.forward(speed) def find_line(): print('running find') robot.stop() sleep(0.2) period = 0.05 while True: start = time() robot.right(speed + 0.1) while time() < (start + period): print('Searching right with period,', period) if line.line_detected: robot.stop() print('line detected') return 1 pass period += 0.05
from gpiozero import LineSensor, LED import paho.mqtt.client as mqtt from time import sleep import json import os mqtt_user = os.environ["MQTT_USER"] mqtt_passwd = os.environ["MQTT_PASSWD"] mqtt_host = os.environ["MQTT_HOST"] sensor_north = LineSensor(12, pull_up=True, queue_len=50) sensor_south = LineSensor(16, pull_up=True, queue_len=50) # Use LED to utilize blink() to pulse the relay relay_north = LED(5, active_high=False) relay_south = LED(6, active_high=False) client = mqtt.Client() client.username_pw_set(mqtt_user, password=mqtt_passwd) client.connect(mqtt_host) # Required to allow the state of the doors to be learned upon startup state_north = None state_south = None # Home Assistant defaults payload_open = "OPEN" payload_close = "CLOSE" # Report the state of the door via MQTT
def setupSensor(self): self._sensor = LineSensor(self.gpio_pin) self._sensor.when_activated = self.beginTray self._sensor.when_deactivated = self.endTray
delta_sec = time_detected - prev_time rpm = 60 / delta_sec print(rpm) async def test(websocket, path): old_rpm = 0 global rpm, count while True: if rpm == old_rpm: count += 1 else: count = 0 if count > 3: rpm = 0 else: old_rpm = rpm now = str(rpm) await websocket.send(now) time.sleep(1) start_server = websockets.serve(test, '127.0.0.1', 8080) sensor = LineSensor(15, queue_len=1) sensor.when_line = lambda: line_detected() sensor.when_no_line = lambda: print('No line detected') asyncio.get_event_loop().run_until_complete(start_server) asyncio.get_event_loop().run_forever()
from Robot import Motor from gpiozero import LineSensor from time import sleep import numpy as np import cv2 speed = 32 #defining line sensors left_sensor = LineSensor(21) right_sensor = LineSensor(26) #defining left and right motors right_motor = Motor(17, 27, 22) left_motor = Motor(23, 24, 25) left_motor.set_speed(speed) right_motor.set_speed(speed) video_capture = cv2.VideoCapture(-1) video_capture.set(3, 160) video_capture.set(4, 120) while (True): ret, frame = video_capture.read() crop_img = frame[60:120, 0:160] gray = cv2.cvtColor(crop_img, cv2.COLOR_BGR2GRAY) blur = cv2.GaussianBlur(gray, (5, 5), 0) ret, thresh = cv2.threshold(blur, 60, 255, cv2.THRESH_BINARY_INV)
# CamJam EduKit 3 - Robotics # Worksheet 5 – Line Detection from gpiozero import LineSensor # Import the LineSensor from the GPIOZero Library from signal import pause # import pause frm the signal library #set up the GPIO pin for the line sensor sensor = LineSensor(25) sensor.when_line = lambda: print('The sensor is seeing a black surface') sensor.when_no_line = lambda: print('The sensor is seeing a white surface') pause() # If you press CTRL+C, cleanup and stop except KeyboardInterrupt: GPIO.cleanup()
class LineNavigator: # Time interval between subsequent sensor readings. _FRAME_RATE_s = 100e-6 # 100 us class _State(enum.Enum): LEFT_ON_TRACK = 0 RIGHT_ON_TRACK = 1 BOTH_ON_TRACK = 2 NONE_ON_TRACK = 3 def __init__(self, driver, status_led, black_track=True): self._driver = driver self._status_led = status_led self._black_track = black_track self._sensor_left = LineSensor(pin=PIN_LEFT_LINE_SENSOR, pull_up=lts.IS_PULL_UP) self._sensor_right = LineSensor(pin=PIN_RIGHT_LINE_SENSOR, pull_up=lts.IS_PULL_UP) # These callback functions are called the first time that one of the # relative events occurs. self._callbacks = { self._State.BOTH_ON_TRACK: self._both_on_track_callback, self._State.LEFT_ON_TRACK: self._left_on_track_callback, self._State.RIGHT_ON_TRACK: self._right_on_track_callback, self._State.NONE_ON_TRACK: self._none_on_track_callback, } # Assume the robot is well-centered on the track. self._state = self._State.NONE_ON_TRACK self._status_led.set(ls.Status.AUTOPILOT) _logger.info('{} initialized'.format(self.__class__.__name__)) def _none_on_track_callback(self): # Reset forward direction. self._driver.set_command(command_code=dvr.COMMAND_RIGHT, command_value=False) self._driver.set_command(command_code=dvr.COMMAND_LEFT, command_value=False) self._driver.set_command(command_code=dvr.COMMAND_FORWARD, command_value=True) _logger.debug('No line detected: go straight ahead') def _left_on_track_callback(self): # Sharp turn to left. self._driver.set_command(command_code=dvr.COMMAND_FORWARD, command_value=False) self._driver.set_command(command_code=dvr.COMMAND_LEFT, command_value=True) _logger.debug('Adjust left') def _right_on_track_callback(self): # Sharp turn to right. self._driver.set_command(command_code=dvr.COMMAND_FORWARD, command_value=False) self._driver.set_command(command_code=dvr.COMMAND_RIGHT, command_value=True) _logger.debug('Adjust right') def _both_on_track_callback(self): self._driver.stop() _logger.warning('Both line sensors detected a line: stop the motors') def run(self): # Start the robot. self._driver.set_command(command_code=dvr.COMMAND_FORWARD, command_value=True) while True: # Active sensor means that the track was detected. if self._black_track: left = not self._sensor_left.is_active right = not self._sensor_right.is_active else: left = self._sensor_left.is_active right = self._sensor_right.is_active if left and right: self._state = self._State.BOTH_ON_TRACK elif left and not right: self._state = self._State.LEFT_ON_TRACK elif not left and right: self._state = self._State.RIGHT_ON_TRACK else: self._state = self._State.NONE_ON_TRACK callback = self._callbacks[self._state] if callback is not None: callback() time.sleep(self._FRAME_RATE_s) def close(self): self._driver.stop() self._sensor_left.close() self._sensor_right.close() _logger.info('{} stopped'.format(self.__class__.__name__))
from time import sleep from gpiozero import Robot, LineSensor robot = Robot(left=(7, 8), right=(9, 10)) left_sensor = LineSensor(17) right_sensor = LineSensor(4) front_sensor = LineSensor(27) speed = 0.5 def motor_speed(): while True: left_detect = int(left_sensor.value) right_detect = int(right_sensor.value) front_detect = int(front_sensor.value) left_mot = 0 right_mot = 0 if left_detect == 0 and right_detect == 1: left_mot = 1 elif left_detect == 1 and right_detect == 0: right_mot = -1 elif front_detect == 0: right_mot, left_mot = 0, 0 else: left_mot = -1 right_mot = 0.9 yield right_mot, left_mot
#LineSensor test from gpiozero import LineSensor from time import sleep from signal import pause def lineDetected(): print('line detected') def noLineDetected(): print('no line detected') sensor = LineSensor(14) sensor.when_line = lineDetected sensor.when_no_line = noLineDetected pause() sensor.close()
#!/usr/bin/python3 import os from gpiozero import LineSensor from signal import pause # script that uses gpiozero library with the LineSensor 'drivers' and # functions # when IR sensor detect somethig between the sensor and her range we save the # time in line.log # when IR sensor no detect something between the sensor and her range we save # the time in noline.log # este programa usa la libreria gpiozero que usa unas funciones especificas # para el sensor IR # cuando el sensor IR detecta que hay algo entre el y su rango de deteccion # guarda la fecha en line.log # cuando el sensor detecta que ha dejado de haber algo entre el sensor # y su rango de alcance guarda la fecha en noline.log directorio = "/tmp/miriadax/" sensor = LineSensor(26) sensor.when_line = lambda: os.system('date +"%s" > ' + directorio + '/line.log' ) sensor.when_no_line = lambda: os.system('date +"%s" >' + directorio + '/noline.log') pause( ) # it wait for another signal from sensor // se mantiene a la espera de otra señal del sensor
# CamJam EduKit 3 - Robotics # Worksheet 8 - Line Following Robot import time # Import the Time library from gpiozero import CamJamKitRobot, LineSensor # Import the GPIO Zero Library # Set variables for the line detector GPIO pin pinLineFollower = 25 linesensor = LineSensor(pinLineFollower) robot = CamJamKitRobot() # Set the relative speeds of the two motors, between 0.0 and 1.0 leftmotorspeed = 0.5 rightmotorspeed = 0.5 motorforward = (leftmotorspeed, rightmotorspeed) motorbackward = (-leftmotorspeed, -rightmotorspeed) motorleft = (leftmotorspeed, -rightmotorspeed) motorright = (-leftmotorspeed, rightmotorspeed) direction = True # The direction the robot will turn - True = Left isoverblack = True # A flag to say the robot can see a black line linelost = False # A flag that is set if the line has been lost # Define the functions that will be called when the line is # detected or not detected def lineseen(): global isoverblack, linelost print("The line has been found.")
mqtt_update(0.5, mqtt_topic) except: logging.warn("Failed to update influxdb") meter_lastupdate = now logging.info("Updated water meter") def call1(): logging.debug("Line detected - {}".format(meter_sensor._queue.queue)) update() def call2(): logging.debug("No line detected - {}".format(meter_sensor._queue.queue)) update() # Initiate line sensor from GPIO. We use 20Hz and a queue length of 5, such # that we have an effective sample rate of 5 Hz (supersampled 5x). Default # is 100 Hz but this takes more CPU than needed for this slow meter logging.debug("Initiating linesensor, queue_len 10, sample @ 40Hz") meter_sensor = LineSensor(4, queue_len=10, sample_rate=40) meter_sensor.when_line = call1 meter_sensor.when_no_line = call2 # Start waiting loop logging.info("Starting waiting loop forever") pause()
from robot import Robot from time import sleep from gpiozero import LineSensor r=Robot() lsensor=LineSensor(23) rsensor=LineSensor(16) lsensor.when_line=r.turnOffMotors rsensor.when_line=r.turnOffMotors r.set_left(-40) r.set_right(-40) while True: sleep(0.02)
from gpiozero import Robot, LineSensor from time import sleep L_F = 7 L_B = 8 R_F = 9 R_B = 10 LS = 17 RS = 27 robot = Robot(left=(L_F, L_B), right=(R_F, R_B)) l_sensor = LineSensor(LS) r_sensor = LineSensor(RS) speed = 0.68 def motor_speed(): while True: l_detect = int(l_sensor.value) r_detect = int(r_sensor.value) ## Stage 1 if l_detect == 0 and r_detect == 0: l_motor = 1 r_motor = 1 ## Stage 2 if l_detect == 0 and r_detect == 1: l_motor = -1 if l_detect == 1 and r_detect == 0: r_motor = -1 #print(r, l)