def __init__(self, camera_num: int = 0, res: (int, int) = None, # width, height
exposure: float = None):
# initialize
self.logger = logging.getLogger("lidar")
# Setup the RPLidar
PORT_NAME = '/dev/ttyUSB0'
self.lidar = RPLidar(None, PORT_NAME)
if not self.lidar == ??:
self.logger.log(logging.CRITICAL, "Status:Failed to open lidar!")
self.lidar.stop_motor()
self.scan = [0]*360
# Threading Locks, Events
self.lidar_lock = Lock() # before changing capture settings lock them
self.stopped = True
# Init Scan and Thread
self.scan_data = [0]*360
self.new_scan = False
self.stopped = False
self.measured_scanrate = 0.0
Thread.__init__(self)
def __init__(self):
# Setup the RPLidar, 라이다 센서 셋업
PORT_NAME = '/dev/ttyUSB0' # 포트네임 설정
self.lidar = RPLidar(
None,
PORT_NAME) # 해당 포트 네임으로 라이다 객체 생성, None -> motor pin, 모터 작동 시작
time.sleep(2)
def scan3d(self, distance):
import os, time
from math import cos, sin, pi, floor
from adafruit_rplidar import RPLidar
PORT_NAME = '/dev/ttyUSB0'
lidar = RPLidar(None, PORT_NAME)
max_distance = 0
maxPoints = 360
x = []
y = []
scan_data = [0]*360
times = []
print("scanning...")
for scan in lidar.iter_scans():
for (_, angle, distance) in scan:
scan_data[min([359, floor(angle)])] = distance
times.append(time.time_ns())
x, y = process_data(scan_data)
if len(x) >= maxPoints:
break
print('end')
self.x3d.extend(x)
self.y3d.extend(y)
self.lid_times.extend(times)
lidar.stop()
def __init__(self, lower_limit = 0, upper_limit = 360, debug=False):
from adafruit_rplidar import RPLidar
# Setup the RPLidar
PORT_NAME = "/dev/ttyUSB0"
import glob
port_found = False
self.lower_limit = lower_limit
self.upper_limit = upper_limit
temp_list = glob.glob ('/dev/ttyUSB*')
result = []
for a_port in temp_list:
try:
s = serial.Serial(a_port)
s.close()
result.append(a_port)
port_found = True
except serial.SerialException:
pass
if port_found:
self.port = result[0]
self.distances = [] #a list of distance measurements
self.angles = [] # a list of angles corresponding to dist meas above
self.lidar = RPLidar(None, self.port, timeout=3)
self.lidar.clear_input()
time.sleep(1)
self.on = True
#print(self.lidar.get_info())
#print(self.lidar.get_health())
else:
print("No Lidar found")
class Robot:
# Setup the RPLidar
PORT_NAME = '/dev/ttyUSB0'
lidar = RPLidar(None, PORT_NAME)
scan_data = [0] * 360
# Setup I2C
addr = 0x8 # bus address
bus = SMBus(1) # i2c channel
# Define variables
MODE_COLOR = 1
MODE_LINE = 2
Mode = MODE_LINE
# initialize wifi
# wifi = WifiSender()
broadcast = UDPBroadcast()
udp = UDPComm()
try:
print(lidar.info)
for scan in lidar.iter_scans():
for (_, angle, distance) in scan:
scan_data[min([359, floor(angle)])] = distance
# print(scan_data[30])
# bus.write_byte_data(addr, i+1, numb)
except KeyboardInterrupt:
print('Stopping.')
lidar.stop()
lidar.disconnect()
def new_lidar():
# Setup the RPLidar, 라이다 센서 셋업
PORT_NAME = '/dev/ttyUSB0' # 포트네임 설정
lidar = RPLidar(
None, PORT_NAME) # 해당 포트 네임으로 라이다 객체 생성, None -> motor pin, 모터 작동 시작
# time.sleep(2)
return lidar
def run_lidar():
lidar = RPLidar(None, '/dev/ttyUSB0') #check usb port with dmesg
while True:
for scan in lidar.iter_scans():
for (quality, angle, distance) in scan:
if (angle >= 240 and angle <=
300): #center on 267.3, corrected on filter end
print("{:7.2f}, {:7.2f}".format(angle, distance))
def __init__(self, args):
super(RPLidarSensor, self).__init__(args)
self.lidar = RPLidar(None, '/dev/ttyUSB0')
self.scan_data = [0]*360
self.time = datetime.now()
self.count = 0
print(self.lidar.info)
print(self.lidar.health)
t = threading.Thread(target=self._read_scans, args=())
t.daemon = True
t.start()
def run_lidar():
try:
lidar = RPLidar(None,'/dev/ttyUSB0') #check usb port with dmesg
while True:
for scan in lidar.iter_scans():
for(quality, angle, distance) in scan:
if( angle >= 240 and angle <=300): #center on 267.3, corrected on filter end
print(",,,,,{:7.2f}, {:7.2f}".format(angle, distance))
except KeyboardInterrupt:
lidar.stop()
lidar.clear_input()
lidar.disconnect()
finally:
lidar.stop()
lidar.disconnect()
def get_data(smqn, sman, smdn, smln, smsn, l, port_name):
#Apperantly this is the Correct way to do Shared Memory
smq = shared_memory.ShareableList(name=smqn)
sma = shared_memory.ShareableList(name=sman)
smd = shared_memory.ShareableList(name=smdn)
sml = shared_memory.ShareableList(name=smln)
sms = shared_memory.ShareableList(name=smsn)
lidar = RPLidar(None, port_name)
lis = lidar.iter_scans
#Speeding up locks
la = lock.acquire
lr = lock.release
while True: #Code Retry
try:
for scan in lis():
la() #Locking
if sms[0]: break #Graceful Shutdown Reciever
sml[0] = int(len(scan))
for x in range(0, sml[0]):
n = scan[x]
smq[x] = n[0]
sma[x] = n[1]
smd[x] = n[2]
lr() #Unlocking
except RPLidarException as e:
print('RPLidarException')
print(e)
break
except ValueError as e:
print('Failure Due to Access Bug')
print(e)
break
except KeyboardInterrupt as e:
pass
#End of Daemon
if l.locked(): lr() #allow code to run
lidar.stop()
lidar.set_pwm(0)
lidar.disconnect()
print('SCAN STOPPED!')
def getLidarScan(lidar_data_queue):
PORT_NAME = '/dev/ttyUSB0'
lidar = RPLidar(None, PORT_NAME)
scan_data = [0] * 360
try:
print(lidar.info)
for scan in lidar.iter_scans():
for (_, angle, distance) in scan:
scan_data[min([359, floor(angle)])] = distance
## Make sure there is only the newest data in the queue
if lidar_data_queue.empty() is True:
lidar_data_queue.put(scan_data)
else:
temp = lidar_data_queue.get()
lidar_data_queue.put(scan_data)
except KeyboardInterrupt:
print('Stoping.')
lidar.stop()
lidar.disconnect()
def __init__(self, args):
super(ImageGatherer, self).__init__(args)
self.lidar = RPLidar(None, '/dev/ttyUSB0')
self.scan_data = [0] * 360
self.snapshot_time = datetime.now()
image_paths = glob.glob("{}/*.jpg".format(args["imageoutput"]))
if image_paths:
self.snapshot_count = max([
int(os.path.splitext(path.split(os.path.sep)[-1])[0])
for path in image_paths
])
else:
self.snapshot_count = 0
print(self.lidar.info)
print(self.lidar.health)
t = threading.Thread(target=self._read_scans, args=())
t.daemon = True
t.start()
def collect_data(client):
lidar = RPLidar(None, PORT_NAME)
try:
motor.value = False
sleep(2)
motor.value = True
sleep(2)
print(lidar.info)
for scan in lidar.iter_scans():
post(client, scan)
except RPLidarException:
if lidar is not None:
lidar.stop()
lidar.disconnect()
collect_data(client)
except KeyboardInterrupt:
print('Stopping.')
lidar.stop()
lidar.disconnect()
def main(self, config, log, local):
from adafruit_rplidar import RPLidar
from math import cos, sin, radians
while True:
try:
lidar = RPLidar(None, config['lidarPort'])
lidar.set_pwm(config['lidarSpeed'])
try: # Rear LIDAR failure will not impact main LIDAR
import adafruit_tfmini
import serial
uart = serial.Serial("/dev/ttyS0", timeout=1)
rearLidar = adafruit_tfmini.TFmini(uart)
rearLidar.mode = adafruit_tfmini.MODE_SHORT
except Exception as exception:
log["exceptions"].append(str(exception))
while True:
for scan in lidar.iter_scans():
local.scan = scan
try:
rearScan = (rearLidar.distance -
config['rearLidarOverhang'],
rearLidar.strength, rearLidar.mode)
if rearScan[0] <= 0:
rearScan = (None, rearScan.strength,
rearScan.mode)
local.rearScan = rearScan
except Exception as exception:
log["exceptions"].append(str(exception))
except Exception as exception:
log["exceptions"].append(str(exception))
if type(
exception
) == KeyboardInterrupt: # This might not work because it runs it a separate process.
lidar.stop()
lidar.disconnect()
def main():
signal.signal(signal.SIGINT, interrupt_handler)
lidar = RPLidar(None, PORT_NAME, baudrate=256000)
logging.basicConfig(
filename="Datalog/Receiver/lidar_data_{}.log".format(time),
level=logging.INFO)
max_distance = 0
try:
logging.info("Starting scanning>>>")
logging.info(lidar.info)
sleep(10)
for scan in lidar.iter_scans():
for (_, angle, distance) in scan:
data = {"angle": angle, "distance": distance, "time": ctime()}
logging.info(str(data))
except KeyboardInterrupt:
logging.info("Stop scanning")
sys.exit(0)
lidar.stop()
lidar.stop_motor()
lidar.disconnect()
sys.exit(0)
from adafruit_rplidar import RPLidar
from math import floor
PORT_NAME = '/dev/ttyUSB0'
lidar = RPLidar(None, PORT_NAME)
print(lidar.info)
scan_data = [0] * 360
for scan in lidar.iter_scans():
for (_, angle, distance) in scan:
scan_data[min([359, floor(angle)])] = distance
break
with open("data.csv", "w+") as out:
out.write("ANGLE, DISTANCE\n")
for i in range(len(scan_data)):
out.write("{}, {}\n".format(i, scan_data[i]))
out.close()
lidar.stop()
lidar.disconnect()
from math import floor
from adafruit_rplidar import RPLidar
global end_value, count, work, ignore, deq2, stop_value, detect
detect = 0
stop_value = 0
end_value = 0
count = 0
ignore = 0
work = 1 # 동작 가능한 상태는 1 q를 누르면 0이다.
deq2 = deque(
maxlen=1000) #Empty Q create(size 1000) 큐를 전역 변수로 만들어서 모든 곳에서 사용 가능하게 한다.
PORT_NAME = '/dev/ttyUSB0'
lidar = RPLidar(None, PORT_NAME, timeout=3)
####A-Star Node
class Node:
def __init__(self, parent=None, position=None):
self.parent = parent
self.position = position
self.g = 0
self.h = 0
self.f = 0
def __eq__(self, other):
return self.position == other.position
port_name = '/dev/ttyUSB0'
#Basic Initialization
sumlist = [] #Data Array
sumnum = 0
a=0.0
b=0.0
c=0.0
#Class Call Speedups
sa = sumlist.append
tt = time.time
mf = math.floor
#RPLidar Hardware Initialization
lidar = RPLidar(None, port_name)
lis = lidar.iter_scans
#DANGER!!!
#lidar.set_pwm(1023)
#Initalising Size
scan_data = [0]*400
#Getting Scan Data Loop
try:
for scan in lis(): #Wait for Rotation to Complete
a=tt() #Start Time
#Offloading Scan Data
for (_, angle, distance) in scan: #Offloading Scan Data
import os
from math import cos, sin, pi, floor
from adafruit_rplidar import RPLidar
lidar = RPLidar(None, '/dev/ttyUSB0')
try:
print("RPLidar INFO: ")
print(lidar.info)
for scan in lidar.iter_scans():
for (_, angle, distance) in scan:
print([min([359, floor(angle)])], distance)
except KeyboardInterrupt:
print('Stoping.')
lidar.stop()
lidar.disconnect()
import os
from math import cos, sin, pi, floor
import pygame
from adafruit_rplidar import RPLidar
# Set up pygame and the display
os.putenv('SDL_FBDEV', '/dev/fb1')
pygame.init()
lcd = pygame.display.set_mode((320, 240))
pygame.mouse.set_visible(False)
lcd.fill((0, 0, 0))
pygame.display.update()
# Setup the RPLidar
PORT_NAME = 'COM7'
lidar = RPLidar(port='COM7', timeout=1)
# used to scale data to fit on the screen
max_distance = 0
# pylint: disable=redefined-outer-name,global-statement
def process_data(data):
global max_distance
lcd.fill((0, 0, 0))
for angle in range(360):
distance = data[angle]
if distance > 0: # ignore initially ungathered data points
max_distance = max([min([5000, distance]), max_distance])
radians = angle * pi / 180.0
x = distance * cos(radians)
for j in range(cols): # 열 순회
alpha = resize_car[i, j, 3] / 255.0
if i + pos_y >= bg_h or j + pos_x >= bg_w:
continue
bg_img[i + pos_y, j + pos_x] = (1. - alpha) * bg_img[
i + pos_y, j + pos_x] + alpha * resize_car[i, j, 0] # R채널
# bg_img[i+pos_y, j+pos_x, 1] = (1. - alpha) * bg_img[i+pos_y, j+pos_x, 1] + alpha * resize_car[i, j, 1] # G채널
# bg_img[i+pos_y, j+pos_x, 2] = (1. - alpha) * bg_img[i+pos_y, j+pos_x, 2] + alpha * resize_car[i, j, 2] # B채널
return bg_img
if __name__ == "__main__":
# Setup the RPLidar, 라이다 센서 셋업
PORT_NAME = '/dev/ttyUSB0' # 포트네임 설정
lidar = RPLidar(
None, PORT_NAME) # 해당 포트 네임으로 라이다 객체 생성, None -> motor pin, 모터 작동 시작
time.sleep(2)
"""
try:
scan_data = [0]*360 # 360개의 버퍼 생성
print(lidar.info) # 라이다 정보 출력
# iter_scan -> 모터 시작 & 스캔 시작, 단일회전(한바퀴)에 대한 측정값 누적하여 저장(튜플) 값은 부동소수점
sta_time = time.time()
scan = next(lidar.iter_scans())
for (_, angle, distance) in scan: # 레이저 강도, 각도, 거리 순
scan_data[min([359, floor(angle)])] = distance # floor->내림값 구하는 함수, 내림값 구한후 359보다 작은 값인지 검사후 저장, 각도가 인덱스값이 됨
# print(scan_data)
print("소요시간: " + str(time.time()-sta_time))
import os
from math import cos, sin, pi, floor
from adafruit_rplidar import RPLidar
lidar = RPLidar(None, '/dev/ttyUSB0') #check usb port with dmesg
try:
print("RPLidar INFO: ")
print(lidar.info)
for scan in lidar.iter_scans():
for (quality, angle, distance) in scan:
if (angle >= 330 or angle <= 30):
print(quality, angle, distance)
except KeyboardInterrupt:
print('Stoping.')
lidar.stop()
lidar.disconnect()