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()
def expect(depth_frame=None, color_frame=None, nothing_else=False): """ Looks at the syncer queue and gets the next frame from it if available, checking its contents against the expected frame numbers. """ global syncer, playback_status f = syncer.poll_for_frame() if playback_status is not None: countdown = 50 # 5 seconds while not f and playback_status != rs.playback_status.stopped: countdown -= 1 if countdown == 0: break time.sleep(0.1) f = syncer.poll_for_frame() # NOTE: f will never be None if not f: test.check(depth_frame is None, "expected a depth frame") test.check(color_frame is None, "expected a color frame") return False log.d("Got", f) fs = rs.composite_frame(f) if fs: depth = fs.get_depth_frame() else: depth = rs.depth_frame(f) test.info("actual depth", depth) test.check_equal(depth_frame is None, not depth) if depth_frame is not None and depth: test.check_equal(depth.get_frame_number(), depth_frame) if fs: color = fs.get_color_frame() elif not depth: color = rs.video_frame(f) else: color = None test.info("actual color", color) test.check_equal(color_frame is None, not color) if color_frame is not None and color: test.check_equal(color.get_frame_number(), color_frame) if nothing_else: f = syncer.poll_for_frame() test.info("Expected nothing else; actual", f) test.check(not f) return True
return 1 if int(n1) < int(n2): return -1 return 0 if compare_fw_versions(current_fw_version, bundled_fw_version) == 0: # Current is same as bundled if recovered or test.context != 'nightly': # In nightly, we always update; otherwise we try to save time, so do not do anything! log.d('versions are same; skipping FW update') test.finish() test.print_results_and_exit() else: # It is expected that, post-recovery, the FW versions will be the same test.check(not recovered, abort_if_failed=True) update_counter = get_update_counter(device) log.d('update counter:', update_counter) if update_counter >= 19: log.d('resetting update counter') reset_update_counter(device) update_counter = 0 # finding file containing image for FW update image_name = product_line[0:2] + "XX_FW_Image-" + bundled_fw_version + ".bin" image_mask = '(^|/)' + image_name + '$' image_file = None for image in file.find(repo.root, image_mask): image_file = os.path.join(repo.root, image) if not image_file:
test.finish() test.print_results_and_exit() for i in range(test_iterations): log.d("{} Iteration {} {}".format("=" * 50, i, "=" * 50)) # Reset Control values log.d("Resetting Controls...") if (depth_ir_sensor.supports(rs.option.enable_auto_exposure)): depth_ir_sensor.set_option(rs.option.enable_auto_exposure, 0) if (depth_ir_sensor.supports(rs.option.exposure)): depth_ir_sensor.set_option(rs.option.exposure, 1) depth_ir_sensor.set_option(rs.option.gain, 248) log.d("Resetting Controls Done") time.sleep(0.1) for val in gain_values: log.d("Setting Gain To: {}".format(val)) depth_ir_sensor.set_option(rs.option.gain, val) get_val = depth_ir_sensor.get_option(rs.option.gain) test.check(val == get_val) log.d("Gain Set To: {}".format(get_val)) test.finish() ################################################################################################ test.print_results_and_exit()
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": max_delay_for_depth_frame = 2.5 # L515 depth frame has a 1.5 seconds built in delay at the FW side + 1.0 second for LRS max_delay_for_color_frame = 1.5 else: log.f("This test support only D400 + L515 devices") ds = dev.first_depth_sensor() cs = dev.first_color_sensor()
def check_firmware_compatible(updatable_device, fw_image): test.check(updatable_device.check_firmware_compatibility(fw_image))
# 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()
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 ) depth_sensor.start( lambda f: None ) try: d2r.trigger_device_calibration( rs.calibration_type.manual_depth_to_rgb ) ac.wait_for_calibration() ac.trim_irrelevant_statuses(irrelevant_statuses) filter_special_frames( ac.status_list ) test.check_equal_lists(ac.status_list, successful_calibration_status_list) except Exception:
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 and p.stream_type() == rs.stream.depth and p.format() == rs.format.fg
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() ds = dev.first_depth_sensor() test.check(ds.supports(rs.option.depth_units)) test.check_equal(ds.get_option(rs.option.depth_units), depth_units_from_metadata) pipeline.stop() except Exception: test.unexpected_exception() test.finish() test.print_results_and_exit()
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) test.check_equal(n_ir_frame, 0) depth_sensor.stop() depth_sensor.close() time.sleep(1) # Allow time to ensure no more frame callbacks after stopping sensor test.finish() n_depth_frame = 0 n_ir_frame = 0 # Test Part 2 test.start("Ask for depth+IR - make sure both frames arrive")
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) ir_1_stream_found = False ir_2_stream_found = False color_stream_found = False for f in frames: profile = f.get_profile() if profile.stream_type() == rs.stream.infrared: if profile.stream_index() == 1: ir_1_stream_found = True elif profile.stream_index() == 2: ir_2_stream_found = True elif profile.stream_type() == rs.stream.color: color_stream_found = True test.check(ir_1_stream_found and ir_2_stream_found and color_stream_found) pass
depth_sensor = playback.first_depth_sensor() color_sensor = playback.first_color_sensor() restart_profiles() depth_sensor.open(dp) depth_sensor.start(depth_frame_call_back) color_sensor.open(cp) color_sensor.start(color_frame_call_back) time.sleep(3) # if record and playback worked we will receive frames, the callback functions will be called and got-frames # will be True. If the record and playback failed it will be false test.check(got_frames_depth) test.check(got_frames_rgb) except Exception: test.unexpected_exception() finally: # we must remove all references to the file so we can use it again in the next test stop_sensor(depth_sensor) depth_sensor = None stop_sensor(color_sensor) color_sensor = None if recorder: recorder = None if playback: playback = None test.finish()
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) test.finish() ################################################################################################ test.print_results_and_exit()
depth_sensor = playback.first_depth_sensor() color_sensor = playback.first_color_sensor() restart_profiles() depth_sensor.open(dp) depth_sensor.start(depth_frame_call_back) color_sensor.open(cp) color_sensor.start(color_frame_call_back) time.sleep(3) # if record and playback worked we will receive frames, the callback functions will be called and got-frames # will be True. If the record and playback failed it will be false test.check(got_frames) except Exception: test.unexpected_exception() finally: # we must remove all references to the file so we can use it again in the next test if recorder: recorder.pause() recorder = None if playback: playback.pause() playback = None stop_sensor(depth_sensor) depth_sensor = None stop_sensor(color_sensor) color_sensor = None test.finish()
lrs_fq = LRSFrameQueueManager() lrs_fq.register_callback(cb) pipe = rs.pipeline() test.start("Testing color frame drops on " + product_line + " device ") for i in range(iterations): lrs_fq.start() print('iteration #{}'.format(i)) hw_ts = [] print('\tStart stream'.format(i)) cfg = rs.config() cfg.enable_stream(rs.stream.color, width, height, _format, fps) pipe.start(cfg, lrs_fq.lrs_queue) time.sleep(sleep) print('\tStop stream'.format(i)) pipe.stop() expected_delta = 1000 / fps deltas_ms = [(ts1 - ts2) / 1000 for ts1, ts2 in zip(hw_ts[1:], hw_ts[:-1])] count_drops = False for idx, delta in enumerate(deltas_ms, 1): if delta > (expected_delta * 1.95): count_drops = True print('\tFound drop #{} actual delta {} vs expected delta: {}'. format(idx, delta, expected_delta)) lrs_fq.stop() test.check(not count_drops) test.finish()