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)
