test.check(not updatable_device.check_firmware_compatibility(fw_image))
def check_firmware_compatible(updatable_device, fw_image):
test.check(updatable_device.check_firmware_compatibility(fw_image))
def get_fw_version_path(product_line_dir, fw_version):
return fw_dir + product_line_dir + fw_version
ctx = rs.context()
dev = ctx.query_devices()[0]
updatable_device = dev.as_updatable()
product_line_dir = dev.get_info(rs.camera_info.product_line) + '/'
#############################################################################################
test.start("checking firmware compatibility with device")
# test scenario:
# get min fw for device, check compatibility, check one before is not compatible
# get max fw for device, check compatibility, check one after is not compatible
# skip any case that is not applicable (for example, max version to check is only for SR300)
pid = dev.get_info(rs.camera_info.product_id)
print(dev.get_info(rs.camera_info.name) + " found")
if pid in pid_to_min_fw_version:
min_fw_version = pid_to_min_fw_version[pid]
min_fw_version_path = get_fw_version_path(product_line_dir, min_fw_version)
print("fw min version: " + min_fw_version)
with open(min_fw_version_path, 'rb') as binary_file:
fw_image = bytearray(binary_file.read())
check_firmware_compatible(updatable_device, fw_image)
rs.format.yuyv and p.as_video_stream_profile().width() == 1280
and p.as_video_stream_profile().height() == 720)
dp = next(
p for p in depth_sensor.profiles
if p.fps() == 30 and p.stream_type() == rs.stream.depth and p.format() ==
rs.format.z16 and p.as_video_stream_profile().width() == 1024
and p.as_video_stream_profile().height() == 768)
depth_sensor.open(dp)
depth_sensor.start(lambda f: None)
color_sensor.open(cp)
color_sensor.start(lambda f: None)
#############################################################################################
test.start("Failing check_conditions function")
# If ambient light is RS2_DIGITAL_GAIN_LOW (2) receiver_gain must be 18
# If ambient light is RS2_DIGITAL_GAIN_HIGH (1) receiver_gain must be 9
old_receiver_gain = depth_sensor.get_option(rs.option.receiver_gain)
depth_sensor.set_option(rs.option.receiver_gain, 15)
try:
d2r.trigger_device_calibration(rs.calibration_type.manual_depth_to_rgb)
test.unreachable()
ac.wait_for_calibration()
except Exception as e:
test.check_exception(e, RuntimeError)
else:
test.unexpected_exception()
test.check_equal_lists(ac.status_list, [rs.calibration_status.bad_conditions])
depth_sensor.set_option(rs.option.receiver_gain, old_receiver_gain)
test.finish()
# License: Apache 2.0. See LICENSE file in root directory.
# Copyright(c) 2021 Intel Corporation. All Rights Reserved.
#test:device each(L500*)
#test:device each(D400*)
#test:priority 1
#test:flag windows
import pyrealsense2 as rs
from rspy import test, log
test.start("checking metadata is enabled")
dev = test.find_first_device_or_exit()
test.check(dev.is_metadata_enabled())
test.finish()
test.print_results_and_exit()
# License: Apache 2.0. See LICENSE file in root directory.
# Copyright(c) 2021 Intel Corporation. All Rights Reserved.
#test:timeout 20
import os
import pyrealsense2 as rs2
from rspy import test
import tempfile
# This test checks that stop of pipeline with playback file
# and non realtime mode is not stuck due to deadlock of
# pipeline stop thread and syncer blocking enqueue thread (DSO-15157)
#############################################################################################
test.start("Playback with non realtime isn't stuck at stop")
filename = tempfile.gettempdir() + os.sep + 'recording_deadlock.bag'
pipeline = rs2.pipeline()
config = rs2.config()
config.enable_all_streams()
config.enable_device_from_file(filename, repeat_playback=False)
profile = pipeline.start(config)
device = profile.get_device().as_playback().set_real_time(False)
success = True
while success:
success, _ = pipeline.try_wait_for_frames(1000)
print("stopping...")
pipeline.stop()
print("stopped")
else:
log.f("This test support only D400 + L515 devices")
def time_to_first_frame(config):
pipe = rs.pipeline()
start_call_stopwatch = Stopwatch()
pipe.start(config)
pipe.wait_for_frames()
delay = start_call_stopwatch.get_elapsed()
pipe.stop()
return delay
################################################################################################
test.start("Testing pipeline first depth frame delay on " + product_line + " device - " + platform.system() + " OS")
depth_cfg = rs.config()
depth_cfg.enable_stream(rs.stream.depth, rs.format.z16, 30)
frame_delay = time_to_first_frame(depth_cfg)
print("Delay from pipeline.start() until first depth frame is: {:.3f} [sec] max allowed is: {:.1f} [sec] ".format(frame_delay, max_delay_for_depth_frame))
test.check(frame_delay < max_delay_for_depth_frame)
test.finish()
################################################################################################
test.start("Testing pipeline first color frame delay on " + product_line + " device - " + platform.system() + " OS")
color_cfg = rs.config()
color_cfg.enable_stream(rs.stream.color, rs.format.rgb8, 30)
frame_delay = time_to_first_frame(color_cfg)
print("Delay from pipeline.start() until first color frame is: {:.3f} [sec] max allowed is: {:.1f} [sec] ".format(frame_delay, max_delay_for_color_frame))
test.check(frame_delay < max_delay_for_color_frame)
if not fw_updater_exe:
log.f("Could not find the update tool file (rs-fw-update.exe)")
devices.query(monitor_changes=False)
sn_list = devices.all()
# acroname should ensure there is always 1 available device
if len(sn_list) != 1:
log.f("Expected 1 device, got", len(sn_list))
device = devices.get_first(sn_list).handle
log.d('found:', device)
product_line = device.get_info(rs.camera_info.product_line)
log.d('product line:', product_line)
###############################################################################
#
test.start("Update FW")
# check if recovery. If so recover
recovered = False
if device.is_update_device():
log.d("recovering device ...")
try:
# TODO: this needs to improve for L535
image_name = product_line[:-2] + "XX_FW_Image-"
image_mask = '(^|/)' + image_name + '(\d+\.){4}bin$'
image_file = None
for image in file.find(repo.root, image_mask):
image_file = image
if not image_file:
log.f("Could not find image file for", product_line,
"recovery device")
and p.format() == rs.format.yuyv
and p.as_video_stream_profile().width() == 640
and p.as_video_stream_profile().height() == 480)
depth_sensor.open(depth_profile)
depth_sensor.start(check_depth_frame_drops)
color_sensor.open(color_profile)
color_sensor.start(check_color_frame_drops)
#############################################################################################
# Test #1
laser_power = rs.option.laser_power
current_laser_control = 10
test.start("Checking for frame drops when setting laser power several times")
for i in range(1,5):
new_value = current_laser_control + 10*i
set_new_value(depth_sensor, laser_power, new_value)
test.finish()
# reset everything back
depth_sensor.set_option( rs.option.visual_preset, int(rs.l500_visual_preset.max_range) )
#############################################################################################
options_to_ignore = []
n_depth_frame = 0
n_ir_frame = 0
def frames_counter(frame):
if frame.get_profile().stream_type() == rs.stream.depth:
global n_depth_frame
n_depth_frame += 1
elif frame.get_profile().stream_type() == rs.stream.infrared:
global n_ir_frame
n_ir_frame += 1
wait_frames_timer = Timer(MAX_TIME_TO_WAIT_FOR_FRAMES)
# Test Part 1
test.start("Ask for depth only - make sure only depth frames arrive")
depth_sensor.open(dp)
depth_sensor.start(frames_counter)
wait_frames_timer.start()
# we wait for first NUMBER_OF_FRAMES_BEFORE_CHECK frames OR MAX_TIME_TO_WAIT_FOR_FRAMES seconds
while (not wait_frames_timer.has_expired()
and n_depth_frame + n_ir_frame < NUMBER_OF_FRAMES_BEFORE_CHECK):
time.sleep(1)
if wait_frames_timer.has_expired():
print(str(NUMBER_OF_FRAMES_BEFORE_CHECK) + " frames did not arrived at "+ str(MAX_TIME_TO_WAIT_FOR_FRAMES) + " seconds , abort...")
test.fail()
else:
test.check(n_depth_frame >= NUMBER_OF_FRAMES_BEFORE_CHECK)
# License: Apache 2.0. See LICENSE file in root directory.
# Copyright(c) 2020 Intel Corporation. All Rights Reserved.
import pyrealsense2 as rs
from rspy import test,ac
devices = test.find_devices_by_product_line_or_exit(rs.product_line.L500)
depth_sensor = devices[0].first_depth_sensor()
debug_sensor = rs.debug_stream_sensor(depth_sensor)
debug_profiles = debug_sensor.get_debug_stream_profiles()
#############################################################################################
test.start("FG isn't exposed by get_stream_profiles")
matches = list(p for p in depth_sensor.profiles if p.format() == rs.format.fg)
test.check(len(matches) == 0 )
test.finish()
#############################################################################################
test.start("FG exposed by debug_stream_sensor")
matches = list(p for p in debug_profiles if p.format() == rs.format.fg)
test.check(len(matches) > 0 )
test.finish()
#############################################################################################
test.start("streaming FG 800x600")
dp = next(p for p in debug_profiles if p.fps() == 30
# License: Apache 2.0. See LICENSE file in root directory.
# Copyright(c) 2021 Intel Corporation. All Rights Reserved.
#test:device L500*
#test:device D400*
#test:device SR300*
import pyrealsense2 as rs
from rspy import test
#############################################################################################
# get metadata depth units value and make sure it's non zero and equal to the depth sensor matching option value
test.start("checking depth units on metadata")
dev = test.find_first_device_or_exit()
depth_sensor = dev.first_depth_sensor()
try:
cfg = pipeline = None
pipeline = rs.pipeline()
cfg = rs.config()
pipeline_profile = pipeline.start(cfg)
# Check that depth units on meta data is non zero
frame_set = pipeline.wait_for_frames()
depth_frame = frame_set.get_depth_frame()
depth_units_from_metadata = depth_frame.get_units()
test.check(depth_units_from_metadata > 0)
# Check metadata depth unit value match option value
dev = pipeline_profile.get_device()
"Pre Processing Sharpening": 0.0,
"Receiver Gain": 18,
"Reset Camera Accuracy Health": 0.0,
"Sensor Mode": 0.0,
"Trigger Camera Accuracy Health": 0.0,
"Visual Preset": 1,
"Zero Order Enabled": 0.0,
"stream-depth-format": "Z16",
"stream-fps": "30",
"stream-height": "480",
"stream-ir-format": "Y8",
"stream-width": "640"
}
"""
test.start("Trying to load default settings from json")
try:
sd.load_json(data)
visual_preset_number = depth_sensor.get_option(rs.option.visual_preset)
visual_preset_name = rs.l500_visual_preset(int(visual_preset_number))
test.check_equal(visual_preset_name,
rs.l500_visual_preset.low_ambient_light)
except:
test.unexpected_exception()
test.finish()
#############################################################################################
test.start("Trying to load non default presets")
presets = [
rs.l500_visual_preset.custom, rs.l500_visual_preset.no_ambient_light,
# The timestamp jumps are closely correlated to the FPS passed to the video streams: # syncer expects frames to arrive every 1000/FPS milliseconds! sw.fps_c = sw.fps_d = 60 sw.init() import tempfile, os temp_dir = tempfile.TemporaryDirectory( prefix = 'recordings_' ) filename = os.path.join( temp_dir.name, 'rec.bag' ) recorder = rs.recorder( filename, sw.device ) sw.start() ############################################################################################# # test.start( "Init" ) # It can take a few frames for the syncer to actually produce a matched frameset (it doesn't # know what to match to in the beginning) # D C @timestamp comment # -- -- ----------- ---------------- # 0 @0 so next expected frame timestamp is at 0+16.67 # 0 @0 # sw.generate_depth_and_color( frame_number = 0, timestamp = 0 ) sw.expect( depth_frame = 0 ) # syncer doesn't know about C yet, so releases right away sw.expect( color_frame = 0, nothing_else = True ) # no hope for a match: D@0 is already out, so it's released # # NOTE: if the syncer queue wasn't 100 (see above) then we'd only get the color frame! # (it will output D to the queue, then C to the queue, but the queue size is 1 so we lose D)
# test:device D400*
import sys
import pyrealsense2 as rs
from rspy import test
ctx = rs.context()
dev = ctx.query_devices()[0]
pid = dev.get_info(rs.camera_info.product_id)
print(dev.get_info(rs.camera_info.name) + " found")
if pid != "0B5B":
print("This test is dedicated to run with D405 only - stepping over test")
sys.exit(0)
#############################################################################################
test.start("D405 explicit configuration - IR calibration, Color in HD")
try:
pipeline = rs.pipeline()
config = rs.config()
config.enable_stream(rs.stream.infrared, 1, 1288, 808, rs.format.y16, 15)
config.enable_stream(rs.stream.infrared, 2, 1288, 808, rs.format.y16, 15)
config.enable_stream(rs.stream.color, 1280, 720, rs.format.rgb8, 15)
pipeline.start(config)
iteration = 0
while True:
iteration = iteration + 1
if iteration > 10:
break
frames = pipeline.wait_for_frames()
test.check(frames.size() == 3)
rte
) != "stop_streaming() failed. UVC device is not streaming!":
test.unexpected_exception()
except Exception:
test.unexpected_exception()
sensor.close()
# create temporary folder to record to that will be deleted automatically at the end of the script
# (requires that no files are being held open inside this directory. Important to not keep any handle open to a file
# in this directory, any handle as such must be set to None)
temp_dir = tempfile.TemporaryDirectory(prefix='recordings_')
file_name = temp_dir.name + os.sep + 'rec.bag'
################################################################################################
test.start("Trying to record and playback using pipeline interface")
cfg = pipeline = None
try:
# creating a pipeline and recording to a file
pipeline = rs.pipeline()
cfg = rs.config()
cfg.enable_record_to_file(file_name)
pipeline.start(cfg)
time.sleep(3)
pipeline.stop()
# we create a new pipeline and use it to playback from the file we just recoded to
pipeline = rs.pipeline()
cfg = rs.config()
cfg.enable_device_from_file(file_name)
pipeline.start(cfg)
# 2. timeout of 'max_delay_allowed' + 1 extra second reached.
while first_frame_time == max_delay_allowed and open_call_stopwatch.get_elapsed(
) < max_delay_allowed + 1:
time.sleep(0.05)
sensor.stop()
sensor.close()
return first_frame_time
# The device starts at D0 (Operational) state, allow time for it to get into idle state
time.sleep(3)
#####################################################################################################
test.start("Testing device creation time on " + platform.system() + " OS")
device_creation_stopwatch = Stopwatch()
dev = test.find_first_device_or_exit()
device_creation_time = device_creation_stopwatch.get_elapsed()
max_time_for_device_creation = 1.5
print("Device creation time is: {:.3f} [sec] max allowed is: {:.1f} [sec] ".
format(device_creation_time, max_time_for_device_creation))
test.check(device_creation_time < max_time_for_device_creation)
test.finish()
# Set maximum delay for first frame according to product line
product_line = dev.get_info(rs.camera_info.product_line)
if product_line == "D400":
max_delay_for_depth_frame = 1.5
max_delay_for_color_frame = 1.5
elif product_line == "L500":
# Copyright(c) 2021 Intel Corporation. All Rights Reserved.
import pyrealsense2 as rs
from rspy import log, test
import sw
# The timestamp jumps are closely correlated to the FPS passed to the video streams:
# syncer expects frames to arrive every 1000/FPS milliseconds!
sw.fps_d = 100
sw.fps_c = 10
sw.init()
sw.start()
#############################################################################################
#
test.start("Wait for framesets")
# It can take a few frames for the syncer to actually produce a matched frameset (it doesn't
# know what to match to in the beginning)
# D C @timestamp
# -- -- -----------
# 0 @0
# 1 @10
# 0 @0
#
sw.generate_depth_frame(frame_number=0, timestamp=sw.gap_d * 0)
sw.generate_depth_frame(1, sw.gap_d * 1) # @10
sw.generate_color_frame(0, sw.gap_c * 0) # @0 -- small latency
sw.expect(depth_frame=0) # syncer doesn't know about color yet
sw.expect(depth_frame=1)
# test:device D400*
import pyrealsense2 as rs
from rspy import test, log
import time
import datetime
# Test multiple set_pu commands checking that the set control event polling works as expected.
# We expect no exception thrown - See [DSO-17185]
test_iterations = 200
gain_values = [16, 74, 132, 190, 248]
################################################################################################
test.start("Stress test for setting a PU (gain) option")
dev = test.find_first_device_or_exit()
time.sleep(
3
) # The device starts at D0 (Operational) state, allow time for it to get into idle state
depth_ir_sensor = dev.first_depth_sensor()
# Test only devices that supports set gain option
if not depth_ir_sensor.supports(rs.option.gain):
test.finish()
test.print_results_and_exit()
for i in range(test_iterations):
log.d("{} Iteration {} {}".format("=" * 50, i, "=" * 50))
"Ma Temperature": 39.667610168457,
"Mc Temperature": 31.6955661773682,
"Min Distance": 190,
"Noise Estimation": 0.0,
"Noise Filtering": 4,
"Post Processing Sharpening": 1,
"Pre Processing Sharpening": 0.0,
"Receiver Gain": 18,
"Reset Camera Accuracy Health": 0.0,
"Sensor Mode": 0.0,
"Trigger Camera Accuracy Health": 0.0,
"Visual Preset": 1
}
"""
test.start("Trying to load settings with default preset from json")
try:
sd.load_json(low_ambient_data_with_default_preset)
visual_preset_number = depth_sensor.get_option(rs.option.visual_preset)
visual_preset_name = rs.l500_visual_preset(int(visual_preset_number))
# if this check fails it is most likely because FW changed the default settings
equal = test.check_equal(visual_preset_name,
rs.l500_visual_preset.low_ambient_light)
if not equal:
log.w(
"It is possible that FW changed the default settings of the camera."
)
log_settings_differences(low_ambient_data_with_default_preset)
except:
test.unexpected_exception()
if p.fps() == 30 and p.stream_type() == rs.stream.color and p.format() ==
rs.format.yuyv and p.as_video_stream_profile().width() == 640
and p.as_video_stream_profile().height() == 480)
depth_sensor.open(depth_profile)
depth_sensor.start(check_depth_frame_drops)
color_sensor.open(color_profile)
color_sensor.start(check_color_frame_drops)
#############################################################################################
# Test #1
laser_power = rs.option.laser_power
current_laser_control = 10
test.start("Checking for frame drops when setting laser power several times")
for i in range(1, 5):
new_value = current_laser_control + 10 * i
set_new_value(depth_sensor, laser_power, new_value)
test.finish()
# reset everything back
depth_sensor.set_option(rs.option.visual_preset,
int(rs.l500_visual_preset.max_range))
#############################################################################################
# Test #2
time.sleep(0.5) # jic
if delta > ideal_delta + delta_tolerance_in_us:
self.count_drops += 1
self.frame_drops_info[fnum] = fnum - self.prev_fnum
self.prev_hw_timestamp = curr_hw_timestamp
self.prev_fnum = fnum
#print("* frame drops = ", self.count_drops)
def analysis(self):
print("Number of frame drops is {}".format(self.count_drops))
for k, v in self.frame_drops_info:
print("Number of dropped frame before frame ", k, ", is :", v)
test.check(self.count_drops == 0)
test.finish()
test.start("Testing D455 frame drops on " + product_line + " device ")
for ii in range(60):
print("================ Iteration {} ================".format(ii))
test = Test(rgb_sensor)
rgb_sensor.set_option(rs.option.global_time_enabled, 0)
rgb_sensor.open([rgb_profile])
producer_thread = threading.Thread(target=test.produce_frames,
name="producer_thread")
producer_thread.start()
consumer_thread = threading.Thread(target=test.consume_frames,
name="consumer_thread")
consumer_thread.start()
test.start_rgb_sensor()
time.sleep(30)
rs.frame_metadata_value.saturation,
rs.frame_metadata_value.sharpness,
rs.frame_metadata_value.auto_white_balance_temperature,
rs.frame_metadata_value.manual_white_balance]
def check_option_and_metadata_values(option, metadata, value_to_set, frame):
changed = color_sensor.get_option(option)
test.check_equal(changed, value_to_set)
if frame.supports_frame_metadata(metadata):
changed_md = frame.get_frame_metadata(metadata)
test.check_equal(changed_md, value_to_set)
else:
print("metadata " + repr(metadata) + " not supported")
#############################################################################################
test.start("checking color options")
# test scenario:
# for each option, set value, wait 10 frames, check value with get_option and get_frame_metadata
# values set for each option are min, max, and default values
ctx = rs.context()
dev = ctx.query_devices()[0]
try:
color_sensor = dev.first_color_sensor()
# Using a profile common to both L500 and D400
color_profile = next(p for p in color_sensor.profiles if p.fps() == 30
and p.stream_type() == rs.stream.color
and p.format() == rs.format.yuyv
and p.as_video_stream_profile().width() == 640
and p.as_video_stream_profile().height() == 480)
color_sensor.open(color_profile)
def filter_special_frames( list ):
"""
Removes consecutive special frame statuses from the status list since we have a built-in
retry mechanism and more than one request can be made.
E.g., [triggered, special_frame, special_frame, started, successful]
"""
i = 1
while i < len(list):
if list[i - 1] == list[i] == rs.calibration_status.special_frame:
del list[i]
else:
i += 1
#############################################################################################
# Test #1
test.start("Depth sensor is off, should get an error")
try:
d2r.trigger_device_calibration( rs.calibration_type.manual_depth_to_rgb )
ac.wait_for_calibration()
except Exception as e:
test.check_exception(e, RuntimeError, "not streaming")
else:
test.unexpected_exception() # No error Occurred, should have received a RuntimeError
test.check(ac.status_list_is_empty()) # No status changes are expected, list should remain empty
test.finish()
#############################################################################################
# Test #2
test.start("Color sensor is off, calibration should succeed")
ac.reset_status_list() # Deleting previous test
depth_sensor.open( dp )
def depth_frame_call_back(frame):
global previous_depth_frame_number
test.check_frame_drops(frame, previous_depth_frame_number)
previous_depth_frame_number = frame.get_frame_number()
depth_sensor.open(dp)
depth_sensor.start(depth_frame_call_back)
color_sensor.open(cp)
color_sensor.start(color_frame_call_back)
#############################################################################################
# Test #1
test.start("Checking for frame drops in", n_cal, "calibrations")
for i in range(n_cal):
try:
dcs.reset_calibration()
ccs.reset_calibration()
d2r.trigger_device_calibration(rs.calibration_type.manual_depth_to_rgb)
ac.wait_for_calibration()
except:
test.unexpected_exception()
test.finish()
#############################################################################################
# Test #2
test.start("Checking for frame drops in a failed calibration")
ac.reset_status_list()
try:
# License: Apache 2.0. See LICENSE file in root directory.
# Copyright(c) 2021 Intel Corporation. All Rights Reserved.
import pyrealsense2 as rs
from rspy import log, test
import sw
# The timestamp jumps are closely correlated to the FPS passed to the video streams:
# syncer expects frames to arrive every 1000/FPS milliseconds!
sw.fps_c = sw.fps_d = 60
sw.init()
sw.start()
#############################################################################################
#
test.start("Wait for framesets")
# It can take a few frames for the syncer to actually produce a matched frameset (it doesn't
# know what to match to in the beginning)
sw.generate_depth_and_color(frame_number=0, timestamp=0)
sw.expect(depth_frame=0) # syncer doesn't know about color yet
sw.expect(color_frame=0, nothing_else=True) # less than next expected of D
#
# NOTE: if the syncer queue wasn't 100 (see above) then we'd only get the color frame!
#
sw.generate_depth_and_color(1, sw.gap_d * 1)
sw.expect(depth_frame=1, color_frame=1, nothing_else=True) # frameset 1
test.finish()
#
