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"
})
