def set_calibration_mode(): """API to call the service to activate calibration mode. Returns: dict: Execution status if the API call was successful. """ webserver_node = webserver_publisher_node.get_webserver_node() try: vehicle_state_req = ActiveStateSrv.Request() vehicle_state_req.state = CALIBRATION_MODE vehicle_state_res = call_service_sync(webserver_node.vehicle_state_cli, vehicle_state_req) enable_state_req = EnableStateSrv.Request() enable_state_req.is_active = True enable_state_res = call_service_sync(webserver_node.enable_state_cli, enable_state_req) success = (vehicle_state_res and vehicle_state_res.error == 0 and enable_state_res and enable_state_res.error == 0) if not success: webserver_node.get_logger().error( "Vehicle state service call failed") return jsonify(success=False, reason="Error") return jsonify(success=True) except Exception as ex: webserver_node.get_logger().error( f"Unable to reach vehicle state server: {ex}") return jsonify(success=False, reason="Error")
def api_set_drive_mode(): """API to toggle the drive mode between Autonomous/Manual mode. Returns: dict: Execution status if the API call was successful and error reason if failed. """ webserver_node = webserver_publisher_node.get_webserver_node() drive_mode = request.json.get("drive_mode") if drive_mode is None: return jsonify({"success": False, "reason": "drive_mode must be set."}) webserver_node.get_logger().info(f"Changed the vehicle state to {drive_mode}") drive_mode_state = 0 if drive_mode == "manual" else 1 try: vehicle_state_req = ActiveStateSrv.Request() vehicle_state_req.state = drive_mode_state vehicle_state_res = call_service_sync(webserver_node.vehicle_state_cli, vehicle_state_req) if vehicle_state_res and (vehicle_state_res.error == 0): return jsonify(success=True) else: webserver_node.get_logger().error("Vehicle state service call failed") return jsonify(success=False, reason="Error") except Exception as ex: webserver_node.get_logger().error(f"Unable to reach vehicle state server: {ex}") return jsonify({"success": False, "reason": "Unable to reach vehicle state server."})
def max_nav_throttle(): """API to call the navigation_throttle service to set the throttle scale in the autonomous mode. Returns: dict: Execution status if the API call was successful and error reason if failed. """ webserver_node = webserver_publisher_node.get_webserver_node() nav_throttle = request.json.get("throttle") if nav_throttle is None: return jsonify({"success": False, "reason": "value must be set."}) webserver_node.get_logger().info( f"Setting max navigation throttle to {nav_throttle}") try: set_throttle_req = NavThrottleSrv.Request() set_throttle_req.throttle = nav_throttle / constants.MAX_AUTO_THROTTLE_VAL set_throttle_res = call_service_sync(webserver_node.set_throttle_cli, set_throttle_req) if set_throttle_res and (set_throttle_res.error == 0): return jsonify({"success": True}) else: return jsonify( success=False, reason="Failed to call the navigation throttle service") except Exception as ex: webserver_node.get_logger().error( f"Unable to reach navigation throttle server: {ex}") return jsonify(success=False, reason="Unable to reach navigation throttle server")
def begin_software_update(): """API to call the service to begin the software update process. Returns: dict: Execution status if the API call was successful and error reason if failed. """ webserver_node = webserver_publisher_node.get_webserver_node() try: webserver_node.get_logger().info("Started software update.") begin_sw_update_req = BeginSoftwareUpdateSrv.Request() begin_sw_update_req.sleep_time_before_reboot = SLEEP_TIME_BEFORE_REBOOT begin_sw_update_res = call_service_sync( webserver_node.begin_sw_update_cli, begin_sw_update_req) if begin_sw_update_res and begin_sw_update_res.response_status: return jsonify({"success": True}) else: webserver_node.get_logger().error( "Begin software update service call failed") return jsonify({ "success": False, "reason": "Update service call failed" }) except Exception as ex: webserver_node.get_logger().error( f"Unable to reach begin update server: {ex}") return jsonify({ "success": False, "reason": "Unable to reach begin update server" })
def max_ftl_speed(): """API to call the SetMaxSpeedSrv service to set the throttle scale in the followtheleader mode. Returns: dict: Execution status if the API call was successful and error reason if failed. """ webserver_node = webserver_publisher_node.get_webserver_node() ftl_speed = request.json.get("throttle") if ftl_speed is None: return jsonify({"success": False, "reason": "value must be set."}) webserver_node.get_logger().info(f"Setting max ftl speed to {ftl_speed}%") try: set_speed_req = SetMaxSpeedSrv.Request() set_speed_req.max_speed_pct = float(ftl_speed / 100) set_speed_res = call_service_sync(webserver_node.set_ftl_max_speed_cli, set_speed_req) if set_speed_res and (set_speed_res.error == 0): return jsonify({"success": True}) else: return jsonify(success=False, reason="Failed to call the SetMaxSpeed service") except Exception as ex: webserver_node.get_logger().error( f"Unable to reach SetMaxSpeed server: {ex}") return jsonify(success=False, reason="Unable to reach SetMaxSpeed server")
def get_sensor_status(): """Helper function to call the service to get the status of the sensor connected to the vehicle. Returns: tuple: A tuple with error code and SensorStatusCheckSrv.Response object. """ webserver_node = webserver_publisher_node.get_webserver_node() try: sensor_status_req = SensorStatusCheckSrv.Request() sensor_status_res = call_service_sync(webserver_node.sensor_status_cli, sensor_status_req) if sensor_status_res and sensor_status_res.error == 0: webserver_node.get_logger().info( "Verify required sensor status: " f"Camera status: {sensor_status_res.single_camera_status}, " f"Stereo status: {sensor_status_res.stereo_camera_status}, " f"Lidar status: {sensor_status_res.lidar_status}") return 0, sensor_status_res else: webserver_node.get_logger().error( "Failed to call the sensor status service") return 1, {} except Exception as ex: webserver_node.get_logger().error( f"Unable to reach sensor status server: {ex}") return 1, {}
def control_modes_available(): """API to call the GetCtrlModesCountSrv service to get the list of available modes in ctrl_pkg (autonomous/manual/calibration/followtheleader). Returns: dict: Execution status if the API call was successful, list of available modes and error reason if call fails. """ webserver_node = webserver_publisher_node.get_webserver_node() webserver_node.get_logger().info("Providing the number of available modes") try: get_ctrl_modes_req = GetCtrlModesSrv.Request() get_ctrl_modes_res = call_service_sync( webserver_node.get_ctrl_modes_cli, get_ctrl_modes_req) control_modes_available = list() for mode in get_ctrl_modes_res.modes: control_modes_available.append(constants.MODE_DICT[mode]) data = { "control_modes_available": control_modes_available, "success": True } return jsonify(data) except Exception as ex: webserver_node.get_logger().error( f"Unable to reach get ctrl modes service: {ex}") return jsonify(success=False, reason="Error")
def get_device_info(): """API to call the service to get the current hardware version of the DeepRacer vehicle and the software version of aws-deepracer-core package. Returns: dict: Execution status if the API call was successful, hardware and software version details and error reason if call fails. """ webserver_node = webserver_publisher_node.get_webserver_node() webserver_node.get_logger().info( "Providing hardware and software revision " "details as response") try: get_revision_info_req = GetDeviceInfoSrv.Request() get_revision_info_res = call_service_sync( webserver_node.get_revision_info_cli, get_revision_info_req) if get_revision_info_res and get_revision_info_res.error == 0: data = { "hardware_version": get_revision_info_res.hardware_version, "software_version": get_revision_info_res.software_version, "success": True } webserver_node.get_logger().info( f"Hardware version: {data['hardware_version']}, " f"Software version: {data['software_version']}") else: webserver_node.get_logger().error( "Get device info service call failed") data = {"reason": "Error", "success": False} return jsonify(data) except Exception as ex: webserver_node.get_logger().error( f"Unable to reach revision info server: {ex}") return jsonify(success=False, reason="Error")
def api_set_start_stop(): """API to call the enable_state service to start and stop the vehicle. Returns: dict: Execution status if the API call was successful and error reason if failed. """ webserver_node = webserver_publisher_node.get_webserver_node() start_stop = request.json.get("start_stop") if start_stop is None: return jsonify({"success": False, "reason": "start_stop must be set."}) webserver_node.get_logger().info( f"Changed the enable state to {start_stop}") start_stop_state = False if start_stop == "stop" else True try: enable_state_req = EnableStateSrv.Request() enable_state_req.is_active = start_stop_state enable_state_res = call_service_sync(webserver_node.enable_state_cli, enable_state_req) if enable_state_res and (enable_state_res.error == 0): return jsonify({"success": True}) else: return jsonify({"success": False, "reason": "Error"}) except Exception as ex: webserver_node.get_logger().error( f"Unable to reach enable state server: {ex}") return jsonify({ "success": False, "reason": "Unable to reach enable state server." })
def get_battery_level(): """API to call the service to get the current vehicle battery level information. Returns: dict: Execution status if the API call was successful, vehicle battery level details and error reason if call fails. """ webserver_node = webserver_publisher_node.get_webserver_node() try: battery_level_req = BatteryLevelSrv.Request() battery_level_res = call_service_sync(webserver_node.battery_level_cli, battery_level_req) if battery_level_res: data = {"battery_level": battery_level_res.level, "success": True} webserver_node.get_logger().info( f"Battery Level: {data['battery_level']}") return jsonify(data) else: return jsonify(success=False, reason="Error") except Exception as ex: webserver_node.get_logger().error( f"Unable to reach battery level server: {ex}") return jsonify(success=False, reason="Error")
def model_file_upload(): """API to call the service to upload models to the artifacts directory. Returns: dict: Execution status if the API call was successful and the response message. """ webserver_node = webserver_publisher_node.get_webserver_node() # # Check if the file received is a tar.gz # file_obj = request.files["file"] file_name = file_obj.filename secured_file = secure_filename(file_name) if file_name.endswith(".tar.gz"): folder_name = file_name[:-7] else: return jsonify({ "success": False, "message": "Failed to upload the model. Not a .tar.gz file" }) # Always create a new directory. If the folder already exists. # Delete and Create a new one. dir_path = os.path.join(constants.MODEL_DIRECTORY_PATH, folder_name) if os.path.exists(dir_path): shutil.rmtree(dir_path) os.makedirs(dir_path) # Save the uploaded file in the artifacts directory. webserver_node.get_logger().info( "Uploaded model file: {}".format(file_name)) file_obj.save(os.path.join(dir_path, secured_file)) # Optimizing the model once the file is uploaded. # Converting the .tar.gz to optimized inference model. upload_model_req = ConsoleModelActionSrv.Request() upload_model_req.model_path = dir_path # action=1 (For upload the model) & action=0 for deleting the model upload_model_req.action = 1 upload_model_res = call_service_sync(webserver_node.model_action_cli, upload_model_req) if upload_model_res: webserver_node.get_logger().info( f"Uploaded model status return {upload_model_res.status}") if upload_model_res.status == "done-upload": return jsonify({ "success": True, "message": "Model uploaded successfully to your vehicle" }) return jsonify({ "success": False, "message": "Failed to upload & optimize the model" })
def events(): webserver_node.get_logger().info( "Running software update event source") for i, c in enumerate(itertools.cycle("\|/-")): try: pct_dict = webserver_node.pct_dict_db.get_nowait() percentage_completion = pct_dict["update_pct"] result = f"status:{pct_dict['status']}|update_pct:{percentage_completion}" yield "data: %s %d\n\n" % (result, i) if (percentage_completion == 100): webserver_node.get_logger().info( "software update event source result: " f"{result}") request = True sw_update_status_req = SoftwareUpdateStateSrv.Request() sw_update_status_req.request = request sw_update_status_res = call_service_sync( webserver_node.sw_update_status_cli, sw_update_status_req) if sw_update_status_res: # Check if software update state is set. if sw_update_status_res.update_state == 0: # Write to software udpate status as atleast one # update has completed successfully. with open(SOFTWARE_UPDATE_STATUS_PATH, "w") \ as software_update_status_file: software_update_status = { "update_completed": True } json.dump(software_update_status, software_update_status_file) break else: webserver_node.get_logger().error( "Unable to reach update status service: " f"{sw_update_status_res}") result = "status:complete|update_pct:100" yield f"data: {result} {1}\n\n" # The sleep is introduced here so as to fetch the next message from # the software_update_status service. This is rate at which the UI shows # the change in the status querying the service. So this will provide us # to control the rate at which we would like to see the software update # information on the browser. For now its set to 1 seconds. time.sleep(SOFTWARE_UPDATE_FETCH_FREQUENCY) except Exception as ex: webserver_node.get_logger().error( f"Unable to reach update status service: {ex}") result = "status:checking|update_pct:0" yield f"data: {result} {1}\n\n" break
def is_model_loading(): """API to stream the model loading status. Returns: flask.Response: Flask response object with the content_type set to text/event-stream. """ webserver_node = webserver_publisher_node.get_webserver_node() is_model_loading_req = GetModelLoadingStatusSrv.Request() is_model_loading_res = call_service_sync( webserver_node.is_model_loading_cli, is_model_loading_req) model_loading_status = "error" if is_model_loading_res is not None and is_model_loading_res.error == 0: model_loading_status = is_model_loading_res.model_loading_status return jsonify({"success": True, "isModelLoading": model_loading_status})
def get_sensor_status(): """API to call the service to get the sensor data status for camera and LiDAR sensors connected to the vehicle. Returns: dict: Execution status if the API call was successful, sensor status information and error reason if call fails. """ webserver_node = webserver_publisher_node.get_webserver_node() data = { "camera_status": "checking", "stereo_status": "checking", "lidar_status": "checking", "success": True } try: sensor_status_req = SensorStatusCheckSrv.Request() sensor_status_res = call_service_sync(webserver_node.sensor_status_cli, sensor_status_req) if sensor_status_res and sensor_status_res.error == 0: data["camera_status"] = \ "not_connected" if sensor_status_res.single_camera_status == 1 else "connected" data["stereo_status"] = \ "not_connected" if sensor_status_res.stereo_camera_status == 1 else "connected" data["lidar_status"] = \ "not_connected" if sensor_status_res.lidar_status == 1 else "connected" else: webserver_node.get_logger().error( "Get sensor status service call failed") data["camera_status"] = "error" data["stereo_status"] = "error" data["lidar_status"] = "error" except Exception as ex: webserver_node.get_logger().error( "Unable to reach sensor status server: {ex}") data["camera_status"] = "error" data["stereo_status"] = "error" data["lidar_status"] = "error" finally: webserver_node.get_logger().info( f"Camera status: {data['camera_status']}, " f"Stereo status: {data['stereo_status']}, " f"Lidar status: {data['lidar_status']}") return jsonify(data)
def set_led_color(): """API to call the service to set the tail light LED color from the red, green, blue values from front end. Returns: dict: Execution status if the API call was successful and error reason if call fails. """ webserver_node = webserver_publisher_node.get_webserver_node() try: data = request.json if int(data["red"]) < 0 or int(data["red"]) > 255 \ or int(data["green"]) < 0 or int(data["green"]) > 255 \ or int(data["blue"]) < 0 or int(data["blue"]) > 255: return jsonify(success=False, reason="Input is not valid") # Convert to PWM red = int(data["red"]) * LED_SCALING_FACTOR green = int(data["green"]) * LED_SCALING_FACTOR blue = int(data["blue"]) * LED_SCALING_FACTOR webserver_node.get_logger().info("Set LED Color: " f"Red: {red} " f"Green: {green} " f"Blue: {blue}") set_led_color_req = SetLedCtrlSrv.Request() set_led_color_req.red = red set_led_color_req.green = green set_led_color_req.blue = blue set_led_color_res = call_service_sync(webserver_node.set_led_color_cli, set_led_color_req) if set_led_color_res and set_led_color_res.error == 0: data = {"success": True} else: webserver_node.get_logger().error( "Set led color service call failed") data = {"reason": "Error", "success": False} return jsonify(data) except Exception as ex: webserver_node.get_logger().error( f"Unable to reach set led color server: {ex}") return jsonify(success=False, reason="Error")
def is_software_update_available(): """API to call the service to check if the software update is available. Returns: dict: Execution status if the API call was successful with the software update status and error reason if failed. """ webserver_node = webserver_publisher_node.get_webserver_node() try: sw_update_state_req = SoftwareUpdateCheckSrv.Request() sw_update_state_req.force_update_check = False sw_update_state_res = call_service_sync( webserver_node.sw_update_state_cli, sw_update_state_req, timeout=180) if sw_update_state_res: webserver_node.get_logger().info( "Status returned from software_update_get_state: " f"{sw_update_state_res.software_update_state}") # Software update status == 0 -> up to date, # 1 -> update available, # others -> error/pending/progress state return jsonify({ "success": True, "status": sw_update_state_res.software_update_state == 1 }) else: return jsonify({ "success": False, "reason": "Unable to reach software update state server" }) except Exception as ex: webserver_node.get_logger().error( f"Unable to reach software update state server: {ex}") return jsonify({ "success": False, "reason": "Unable to reach software update state server" })
def check_usb_connection(): """Call the OTGLinkState service to find out if OTG is connected. Returns: dict: Execution status if the service call was successful and the response. """ webserver_node = webserver_publisher_node.get_webserver_node() is_usb_connected = False try: otg_link_state_req = OTGLinkStateSrv.Request() otg_link_state_res = utility.call_service_sync( webserver_node.otg_link_state_cli, otg_link_state_req) is_usb_connected = True if otg_link_state_res and otg_link_state_res.link_state else False except Exception as arg: webserver_node.get_logger().info( f"USB connection check exception: {arg}") webserver_node.get_logger().info( f"Check OTG Link State: {is_usb_connected}") return {"success": True, "is_usb_connected": is_usb_connected}
def delete_model_folder(): """API to call the service to delete models passed as parameter. Takes the folder path as parameter and deletes all the files in that directory. Returns: dict: Execution status if the API call was successful and the response message. """ webserver_node = webserver_publisher_node.get_webserver_node() req = request.json filenames = req["filenames"] webserver_node.get_logger().info(f"Deleting Models {filenames}") deleted_all_models = True # Loop through the filenames and delete the models. for filename in filenames: delete_model_req = ConsoleModelActionSrv.Request() delete_model_req.model_path = os.path.join( constants.MODEL_DIRECTORY_PATH, filename) # action=1 (For upload the model) & action=0 for deleting the model. delete_model_req.action = 0 delete_model_res = call_service_sync(webserver_node.model_action_cli, delete_model_req) if delete_model_res: webserver_node.get_logger().info("Delete model status return " f"{delete_model_res.status}") if delete_model_res.status != "done-delete": deleted_all_models = False else: deleted_all_models = False if deleted_all_models: return jsonify({ "success": True, "message": "Models deleted successfully from your vehicle" }) return jsonify({ "success": False, "message": "Failed to delete the selected models" })
def api_set_calibration(cali_type): """API to call the service to store the calibration to file and set the current calibration. Args: cali_type (int): Calibration type identifying steering/throttle calibration. Returns: dict: Execution status if the API call was successful. """ data = request.json webserver_node = webserver_publisher_node.get_webserver_node() webserver_node.get_logger().info(f"set_calibration: {data}") state = 0 if cali_type == "angle" else 1 conversion = PWM_ANGLE_CONVERSION if state == 0 else PWM_THROTTLE_CONVERSION set_mid = int(data["mid"]) * conversion + PWM_OFFSET set_min = int(data["min"]) * conversion + PWM_OFFSET set_max = int(data["max"]) * conversion + PWM_OFFSET set_polarity = int(data["polarity"]) webserver_node.get_logger().info(f"State: {state} " f"mid: {set_mid} " f"min: {set_min} " f"max: {set_max} " f"polarity: {set_polarity}") try: set_cal_req = SetCalibrationSrv.Request() set_cal_req.cal_type = state set_cal_req.min = set_min set_cal_req.max = set_max set_cal_req.mid = set_mid set_cal_req.polarity = set_polarity set_cal_res = call_service_sync(webserver_node.set_cal_cli, set_cal_req) if set_cal_res and set_cal_res.error == 0: return jsonify({"success": True}) else: return jsonify({"success": False}) except Exception as ex: webserver_node.get_logger().error( f"Unable to reach set vehicle calibration server: {ex}") return api_fail("Unable to reach set vehicle calibration")
def api_get_calibration(cali_type): """API to call the service to get the calibration from file with the current calibration. Args: cali_type (int): Calibration type identifying steering/throttle calibration. Returns: dict: Execution status if the API call was successful. """ state = 0 if cali_type == "angle" else 1 conversion = PWM_ANGLE_CONVERSION if state == 0 else PWM_THROTTLE_CONVERSION webserver_node = webserver_publisher_node.get_webserver_node() try: get_cal_req = GetCalibrationSrv.Request() get_cal_req.cal_type = state get_cal_res = call_service_sync(webserver_node.get_cal_cli, get_cal_req) if get_cal_res is None or get_cal_res.error != 0: return api_fail("Unable to reach get vehicle calibration server") except Exception as ex: webserver_node.get_logger().error( f"Unable to reach get vehicle calibration server: {ex}") return api_fail("Unable to reach get vehicle calibration server") converted_min = (get_cal_res.min - PWM_OFFSET) / conversion converted_max = (get_cal_res.max - PWM_OFFSET) / conversion data = { "mid": (get_cal_res.mid - PWM_OFFSET) / conversion, "min": (converted_min if (get_cal_res.polarity) else converted_max), "max": (converted_max if (get_cal_res.polarity) else converted_min), "polarity": get_cal_res.polarity, "success": True } webserver_node.get_logger().info(f"Current calibration state: {state} " f"MID: {data['mid']} " f"MIN: {data['min']} " f"MAX: {data['max']} " f"Polarity: {data['polarity']}") return jsonify(data)
def get_led_color(): """API to call the service to get red, green, blue values for the tail light LED color that is currently active. Returns: dict: Execution status if the API call was successful, channel values for the tail light LED and error reason if call fails. """ webserver_node = webserver_publisher_node.get_webserver_node() webserver_node.get_logger().info("Providing r, b, g values as response") try: get_led_color_req = GetLedCtrlSrv.Request() get_led_color_res = call_service_sync(webserver_node.get_led_color_cli, get_led_color_req) if get_led_color_res: converted_red = get_led_color_res.red // LED_SCALING_FACTOR converted_green = get_led_color_res.green // LED_SCALING_FACTOR converted_blue = get_led_color_res.blue // LED_SCALING_FACTOR data = { "red": converted_red, "green": converted_green, "blue": converted_blue, "success": True } webserver_node.get_logger().info("Current LED RGB values: " f"Red: {data['red']} " f"Green: {data['green']} " f"Blue: {data['blue']}") return jsonify(data) else: return jsonify(success=False, reason="Error") except Exception as ex: webserver_node.get_logger().error( f"Unable to reach get vehicle led server: {ex}") return jsonify(success=False, reason="Error")
def api_load_model(model_folder_name, model_name): """API to call the service to load model for inference after verifying if its in valid state. Returns: dict: Execution status if the API call was successful and the error reason if failed. """ webserver_node = webserver_publisher_node.get_webserver_node() webserver_node.get_logger().info("Loading {}/{}".format( model_folder_name, model_name)) try: verify_model_ready_req = VerifyModelReadySrv.Request() verify_model_ready_req.model_name = model_folder_name model_verification_res = call_service_sync( webserver_node.verify_model_ready_cli, verify_model_ready_req) webserver_node.get_logger().info( "Model verification completed result " f"{model_verification_res.response_status}") if model_verification_res is None or not model_verification_res.response_status: return jsonify({ "success": False, "reason": "Model optimization failed!" }) err_code, err_msg, model_metadata_content = \ read_model_metadata_file(os.path.join( os.path.join(constants.MODEL_DIRECTORY_PATH, model_folder_name), "model_metadata.json")) if err_code > 0: return jsonify({"success": False, "reason": err_msg}) err_code, err_msg, model_metadata_sensors = get_sensors( model_metadata_content) if err_code > 0: return jsonify({"success": False, "reason": err_msg}) err_code, err_msg, training_algorithm = get_training_algorithm( model_metadata_content) if err_code > 0: return jsonify({"success": False, "reason": err_msg}) err_code, err_msg, action_space_type = get_action_space_type( model_metadata_content) if err_code > 0: return jsonify({"success": False, "reason": err_msg}) err_code, err_msg, action_space = get_action_space( model_metadata_content) if err_code > 0: return jsonify({"success": False, "reason": err_msg}) if not validate_action_space(action_space, action_space_type): return jsonify({ "success": False, "reason": "Incorrect values in model_metadata.json" }) err_code, sensor_resp = get_sensor_status() if err_code > 0: return jsonify({ "success": False, "reason": "Error getting sensor status" }) err_code, err_msg = verify_sensor_connection(model_metadata_sensors, sensor_resp) if err_code > 0: return jsonify({"success": False, "reason": err_msg}) err_code, err_msg, model_lidar_config = load_lidar_configuration( model_metadata_sensors, model_metadata_content) if err_code > 0: return jsonify({"success": False, "reason": err_msg}) # Configure lidar service. Call the service to load model specific lidar configuration # or to reset the lidar configuration to default. configure_lidar_req = LidarConfigSrv.Request() configure_lidar_req.use_lidar = \ model_lidar_config[constants.ModelMetadataKeys.USE_LIDAR] configure_lidar_req.min_angle = \ model_lidar_config[constants.ModelMetadataKeys.MIN_LIDAR_ANGLE] configure_lidar_req.max_angle = \ model_lidar_config[constants.ModelMetadataKeys.MAX_LIDAR_ANGLE] configure_lidar_req.num_values = \ model_lidar_config[constants.ModelMetadataKeys.NUM_LIDAR_VALUES] configure_lidar_req.min_distance = \ model_lidar_config[constants.ModelMetadataKeys.MIN_LIDAR_DIST] configure_lidar_req.max_distance = \ model_lidar_config[constants.ModelMetadataKeys.MAX_LIDAR_DIST] configure_lidar_req.clipping_distance = \ model_lidar_config[constants.ModelMetadataKeys.LIDAR_CLIPPING_DIST] configure_lidar_req.num_sectors = \ model_lidar_config[constants.ModelMetadataKeys.NUM_LIDAR_SECTORS] configure_lidar_req.preprocess_type = \ model_lidar_config[constants.LIDAR_PREPROCESS_KEY] configure_lidar_res = call_service_sync( webserver_node.configure_lidar_cli, configure_lidar_req) webserver_node.get_logger().info( "Setting lidar configuration is completed: " f"{configure_lidar_res.error}") if configure_lidar_res is None or configure_lidar_res.error != 0: return jsonify({ "success": False, "reason": "Setting lidar configuration failed!" }) model_path = model_folder_name + "/" + model_name model_state_req = ModelStateSrv.Request() model_state_req.model_name = model_path model_state_req.model_metadata_sensors = [ sensor.value for sensor in model_metadata_sensors ] model_state_req.training_algorithm = training_algorithm.value model_state_req.action_space_type = action_space_type.value model_state_req.img_format = constants.MODEL_FORMAT model_state_req.width = constants.MODEL_WIDTH model_state_req.height = constants.MODEL_HEIGHT model_state_req.num_channels = constants.MODEL_CHANNELS model_state_req.lidar_channels = \ model_lidar_config[constants.ModelMetadataKeys.NUM_LIDAR_SECTORS] model_state_req.platform = constants.MODEL_PLATFORM model_state_req.task_type = constants.MODEL_TASK_TYPE model_state_req.pre_process_type = constants.MODEL_PRE_PROCESS model_state_res = call_service_sync(webserver_node.model_state_cli, model_state_req) if model_state_res and model_state_res.error == 0: webserver_node.get_logger().info("Model Loaded") return jsonify({"success": True}) else: webserver_node.get_logger().error("Model optimizer error") return jsonify({ "success": False, "reason": "Model load failed! Please check the ROS logs" }) except Exception as ex: webserver_node.get_logger().error( "Unable to reach model state server: {ex}") return jsonify({ "success": False, "reason": "Unable to reach model state server" })