Detailed background information is available in my master's thesis (chapter 4.2 "Autonomous Energy Supply").

Video demonstration of the system in the Gazebo simulation: Autonomous Docking with an Inductive Charging Station.

(a) Robot facing base station (b) Base station perception based on lidar data (c) Successful detection of base station shape:

• Assumed: State: CONTAINER_PROXIMITY
  • robot drove near the container, e.g. based on GPS
  • postcondition: robot faces container in certain area

• State: DETECT_CONTAINER (laser scans, possibly camera)
  • precondition: robot faces container in certain area
  • postcondition: localized container + ramp
• State: ALIGN_ROBOT_TO_RAMP (defined pose)
  • preconditions:
    • robot in front of container
    • localized container + ramp
    • ramp lowered
  • postcondition: robot aligned in front of ramp
• State: DRIVE_INTO_CONTAINER
  • preconditions:
    • robot aligned in front of ramp
    • free space in container
  • postcondition: robot inside the container
• State: LOCALIZE_CHARGING_STATION (laser scans, possibly camera)
  • precondition: robot inside the container
  • postcondition: localized charging station
• State: ALIGN_ROBOT_TO_CHARGING_STATION (defined pose)
  • precondition: localized charging station
  • postcondition: robot aligned with charging station
• State: DOCK
  • precondition: robot aligned with charging station
  • postcondition: robot charging

• Assumed: State: INSIDE_CONTAINER
  • postcondition: robot inside the container
• State: DETECT_ENTRY
  • precondition: robot inside the container
  • postcondition: localized container entry
• State: DRIVE_OUT_OF_CONTAINER
  • precondition: localized container entry
  • postcondition: robot located in front of the container

• arox_docker: dockerization of the AROX system
  • branch: noetic
  • compatible branches within docker container:
    • arox_navigation_flex: low_yaw_goal_tolerance
    • arox_launch: frame_launch
    • arox_indoor_navi: sim_launch_detection_config
    • map_langsenkamp: feature_new_map
• arox_description: ROS launch files and URDF model for the AROX system
  • branch: feature_flying_sick_tim
• container_description: ROS launch files and URDF model for the mobile container (charge station)
  • branch: feature_lta_conatiner
• innok_heros_description: URDF description for Innok Heros robot
  • branch: arox_noetic
• innok_heros_driver: ROS driver for the Innok Heros robot platform
  • branch: master
• velodyne_simulator: URDF and gazebo plugin to provide simulated data from Velodyne laser scanners
  • branch: master
• gazebo_langsenkamp: Langsenkamp world (test field)
  • branch: feature_lta_layout
• [Since the docker container still uses python2, there is a python2 compatible branch feature/python2_compatible]

• run simulation (with GUI): roslaunch arox_description launch_arox_sim.launch gui:=true
• spawn container: roslaunch container_description spawn.launch
• spawn AROX: roslaunch arox_description spawn.launch
• run AROX controllers: roslaunch arox_description run_controllers.launch
• run docker container named 'arox_docking': aroxstartdocker arox_docking (alias)
  • launch outdoor simulation: roslaunch arox_launch arox_sim_outdoor.launch
• provide docking / undocking actions: roslauch arox_docking docking.launch
• start docking / undocking test loop: rosrun arox_docking test_loop.py

The docking / undocking state machines provide implementations of the SimpleActionServer (cf. http://wiki.ros.org/actionlib).
Docking Example

docking_client = actionlib.SimpleActionClient('dock_to_charging_station', DockAction)
goal = DockGoal()
goal.goal = "custom_goal"
docking_client.wait_for_server()
docking_client.send_goal(goal)

Undocking Example

undocking_client = actionlib.SimpleActionClient('undock_from_charging_station', UndockAction)
goal = UndockGoal()
goal.ramp_alignment_pose = robot_pose  # optional
undocking_client.wait_for_server()
undocking_client.send_goal(goal)

• access exploration GUI: http://localhost/exploration_gui/
• run AROX engine: rosrun arox_engine arox_engine.py
• run AROX planner: rosrun arox_planning arox_planner.py

• launch keyboard control: rosrun teleop_twist_keyboard teleop_twist_keyboard.py

• rViz
  • fixed frame: map
  • open the provided config conf.rviz

• rostopic pub -1 /container/rampA_position_controller/command std_msgs/Float64 "data: 1.57"

@inproceedings{Bohne:2023,
    author = {Tim Bohne and Gurunatraj Parthasarathy and Benjamin Kisliuk},
    title = {A systematic approach to the development of long-term autonomous robotic systems for agriculture},
    booktitle = {43. GIL-Jahrestagung, Resiliente Agri-Food-Systeme, 13.-14. Februar 2023, Osnabr{\"{u}}ck, Germany},
    series = {{LNI}},
    volume = {{P-330}},
    pages = {285--290},
    publisher = {Gesellschaft f{\"{u}}r Informatik e.V.},
    year = {2023},
    url = {https://dl.gi.de/handle/20.500.12116/40260},
    biburl = {https://dblp.org/rec/conf/gil/BohnePK23.bib},
    bibsource = {dblp computer science bibliography, https://dblp.org}
}

@mastersthesis{Bohne:2022,
    author = {Bohne, Tim},
    year = {2022},
    month = {04},
    title = {Execution Monitoring for Long-Term Autonomous Plant Observation with a Mobile Robot}
}