Merge pull request #11 from BCLab-UNM/kinetic_kame

Kinetic kame compatibility update

Author: gmfricke

.gitmodules

@@ -1,3 +1,9 @@
 [submodule "src/ublox"]
 	path = src/ublox
 	url = https://github.com/KumarRobotics/ublox.git
+[submodule "apriltags_ros"]
+	path = apriltags_ros
+	url = https://github.com/RIVeR-Lab/apriltags_ros.git
+[submodule "src/apriltags_ros"]
+	path = src/apriltags_ros
+	url = https://github.com/RIVeR-Lab/apriltags_ros.git

README.md

@@ -1,10 +1,10 @@
-# Swarmathon-ROS
+# SwarmBaseCode-ROS
 
-This repository is a ROS (Robot Operating System) controller framework for the Swarmie robots used in the [NASA Swarmathon](http://www.nasaswarmathon.com), a national swarm robotics competition. This particular framework is a ROS implementation of the CPFA (central-place foraging algorithm) developed for [iAnt robot swarms](http://swarms.cs.unm.edu) at the [University of New Mexico](http://www.unm.edu/).
+This repository is a ROS (Robot Operating System) controller framework for the Swarmie robots used in the [NASA Swarmathon](http://www.nasaswarmathon.com), a national swarm robotics competition. 
 
 This repository contains:
 
-1. Source code for ROS libraries (i.e. packages) that control different aspects of the Swarmie robot, including localization, mapping, mobility, and obstacle and target detection
+1. Source code for ROS libraries (i.e. packages) that control different aspects of the Swarmie robot, including robot behaviours such as search strategies and obstacle avoidance, diagnostics, and user interface elements. 
 2. 3D .STL models for the physical Swarmie build 
 3. Bash shell scripts for initializing simulated Swarmies in the Gazebo simulator, as well as physical Swarmies
 
@@ -16,78 +16,86 @@ This repository contains:
 
 - Please consult the [git scm](https://git-scm.com/) and [git best practices](https://sethrobertson.github.io/GitBestPractices/) for guidelines on the most effective approaches to maintaining code. Teams will be expected to commit new code at least every two weeks, and ideally commit one or more times per week. Consult the [NASA Swarmathon Timeline](http://www.nasaswarmathon.com) for specifics on how often code should be committed, as well as the cutoff date for final code revision before the competition.
 
-### Quick Start Installation Guide
+Be: sure you are using the latest drivers for your video card using the "additional drivers tool" in Ubuntu. Gazebo client often does not do well with the open source drivers.
 
-Swarmathon-ROS is designed and tested exclusively on the 64 bit version of Ubuntu 14.04 LTS (Trusty Tahr) and ROS Indigo Igloo. This framework may compile and run correctly under other versions of Ubuntu and ROS, but **NOTE** that these other systems are untested and are therefore not supported at this time.
+![Alt text](https://github.com/BCLab-UNM/SwarmBaseCode-ROS/blob/kinetic_kame/readmeImages/InstallGraphics.png "Additional Drivers")
 
-##### 1. Install ROS Indigo
+### Quick Start Installation Guide
 
-Follow the detailed instructions for installing ROS Indigo under Ubuntu 14.04 [here](http://wiki.ros.org/indigo/Installation/Ubuntu). We recommend the Desktop-Full installation, which includes the Gazebo 2 simulator.
+Swarmathon-ROS is designed and tested exclusively on the 64 bit version of Ubuntu 16.04 LTS (Xenial Xerus) and ROS Kinetic Kame. Other systems are untested and are therefore not supported at this time.
 
-##### 2. Install additional ROS plugins
+##### 1. Install ROS Kinetic Kame
 
-We use the [catkin_tools](https://catkin-tools.readthedocs.io/) package to build the Swarmathon-ROS code base:
+Detailed instructions for installing ROS Kinetic Kame under Ubuntu 16.04 [here](http://wiki.ros.org/kinetic/Installation/Ubuntu) or follow the summarized instructions below:
 
 ```
-sudo apt-get install python-catkin-tools
+sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'
+
+sudo apt-key adv --keyserver hkp://ha.pool.sks-keyservers.net:80 --recv-key 421C365BD9FF1F717815A3895523BAEEB01FA116
+
+sudo apt update
+sudo apt install ros-kinetic-desktop-full
+sudo rosdep init
+rosdep update      # Note this is not run with sudo
 ```
 
-Our simulated and physical Swarmies use existing ROS plugins, external to this repo, to facilitate non-linear state estimation through sensor fusion and frame transforms. These plugins are contained in the [robot_localization](http://wiki.ros.org/robot_localization) package, which should be installed using the apt-get package management tool:
+Note: if you accidentally ran ```sudo rosdep update``` you can repair the permissions ```sudo rosdep fix-permissions```.
+
+##### 2. Install additional ROS packages
+
+We use the [catkin_tools](https://catkin-tools.readthedocs.io/) package to build the Swarmathon-ROS code base:
 
 ```
-sudo apt-get install ros-indigo-robot-localization
+sudo apt install python-rosinstall python-catkin-tools
 ```
 
-We additionally make use of an AprilTag detection plugin to decode tags within images, as well as provide pose estimates for tag positions relative to the lens of the camera. This plugin is contained in the [apriltags_ros](http://wiki.ros.org/apriltags_ros) package, which should be installed using apt-get:
+Our simulated and physical Swarmies use existing ROS plugins, external to this repo, to facilitate non-linear state estimation through sensor fusion and frame transforms. These plugins are contained in the [robot_localization](http://wiki.ros.org/robot_localization) package, which should be installed using the apt-get package management tool:
 
 ```
-sudo apt-get install ros-indigo-apriltags-ros
+sudo apt install ros-kinetic-robot-localization
 ```
 
-Finally, our physical Swarmies use a USB camera driver, contained in the [usb_cam](http://wiki.ros.org/usb_cam) package, to interface with the built-in Logitech C170 webcam:
+Finally, our physical Swarmies use a video stream package [video_stream](http://wiki.ros.org/video_stream_opencv), to interface with the built-in Logitech C170 webcam:
 
 ```
-sudo apt-get install ros-indigo-usb-cam
+sudo apt install ros-kinetic-video-stream-opencv
 ```
 
 ##### 3. Install additional Gazebo plugins
 
 Our simulated Swarmies use existing Gazebo plugins, external to this repo, to replicate sonar, IMU, and GPS sensors. These plugins are contained in the [hector_gazebo_plugins](http://wiki.ros.org/hector_gazebo_plugins) package, which should be installed using the apt-get package management tool:
 
 ```
-sudo apt-get install ros-indigo-hector-gazebo-plugins
+sudo apt install ros-kinetic-hector-gazebo-plugins
 ```
 
-Our Swarmies can receive mobility commands from the right thumb stick on a Microsoft Xbox 360 controller. The ROS [joystick_drivers](http://wiki.ros.org/joystick_drivers) package, which contains a generic Linux joystick driver compatible with this controller, should also be installed using the apt-get tool:
+Thw Swarmies can receive commands from the thumb sticks on a Microsoft Xbox 360 controller. The ROS [joystick_drivers](http://wiki.ros.org/joystick_drivers) package, which contains a generic Linux joystick driver compatible with this controller, should also be installed using the apt tool:
 
 ```
- sudo apt-get install ros-indigo-joystick-drivers
+ sudo apt install ros-kinetic-joystick-drivers
 ```
 
 Joystick commands can also be simulated using the direction keys (Up=I, Down=K, Left=J, Right=L) on the keyboard. The Rover GUI window must have focus for keyboard control to work.
 
 ##### 4. Install git (if git is already installed, skip to step 5):
 
 ```
-sudo apt-get install git
+sudo apt install git
 ```
 
 ##### 5. Install Swarmathon-ROS
 
-1. Clone this GitHub repository to your home directory (~), renaming the repo so ROS and catkin can properly identify it:
+1. Clone this GitHub repository to your home directory (~), renaming the repo so ROS and catkin can properly identify it (you can name the target directory whatever you like):
 
   ```
   cd ~
-  git clone https://github.com/BCLab-UNM/Swarmathon-ROS.git rover_workspace
+  git clone https://github.com/BCLab-UNM/SwarmBaseCode-ROS.git SwarmBaseCode-ROS
   ```
 
-2. Change your current working directory to the root directory of the downloaded repo:
+2. Change your current working directory to the root directory of the downloaded repo.
 
-  ```
-  cd ~/rover_workspace
-  ```
 
-3. Set up [ublox](http://wiki.ros.org/ublox) GPS submodule:
+3. Set up [ublox](http://wiki.ros.org/ublox) GPS submodule and April Tag library:
 
   ```
   git submodule init
@@ -98,9 +106,9 @@ sudo apt-get install git
 
   Make sure bash is aware of the location of the ROS environment:
   ```
-  if ! grep -q "source /opt/ros/indigo/setup.bash" ~/.bashrc
+  if ! grep -q "source /opt/ros/kinetic/setup.bash" ~/.bashrc
   then 
-    echo "source /opt/ros/indigo/setup.bash" >> ~/.bashrc
+    echo "source /opt/ros/kinetic/setup.bash" >> ~/.bashrc
   fi
   source ~/.bashrc
   ```
@@ -110,28 +118,13 @@ sudo apt-get install git
   ```
   catkin build
   ```
-  
-5. Update your bash session to automatically source the setup file for Swarmathon-ROS:
-
-  ```
-  echo "source ~/rover_workspace/devel/setup.bash" >> ~/.bashrc
-  source ~/.bashrc
-  ```
-
-6. Update your bash session to automatically export the enviromental variable that stores the location of Gazebo's model files:
-
-  ```
-  echo "export GAZEBO_MODEL_PATH=~/rover_workspace/simulation/models" >> ~/.bashrc
-  echo "export GAZEBO_PLUGIN_PATH=${GAZEBO_PLUGIN_PATH}:~/rover_workspace/devel/lib/" >> ~/.bashrc
-  source ~/.bashrc
-  ```
-
+    
 ##### 6. Run the Swarmathon-ROS simulation:
 
-1. Change the permissions on the simulation run script to make it exectuatable:
+1. Change the permissions on the simulation run script to make it exectuatable (assuming you use the target directory name SwarmBaseCode-ROS):
 
   ```
-  cd ~/rover_workspace
+  cd ~/SwarmBaseCode-ROS
   chmod +x ./run.sh
   ```
 
@@ -191,16 +184,12 @@ To close the simulation and the GUI, click the red exit button in the top left-h
 
 ### Software Documentation
 
-Source code for Swarmathon-ROS can be found in the ```~/rover_workspace/src``` directory. This diretory contains severals subdirectories, each of which contain a single ROS package. Here we present a high-level description of each package.
+Source code for Swarmathon-ROS can be found in the repository /src directory. This diretory contains severals subdirectories, each of which contain a single ROS package. Here we present a high-level description of each package.
 
-- ```abridge```: A serial interface between Swarmathon-ROS and the A-Star 32U4 microcontroller onboard the physical robot. In the Swarmathon-ROS simulation, ```abridge``` functionality is supplanted by [gazebo_ros_skid_steer_drive](http://docs.ros.org/indigo/api/gazebo_plugins/html/classgazebo_1_1GazeboRosSkidSteerDrive.html) (motor and encoders) and [hector_gazebo_plugins](http://wiki.ros.org/hector_gazebo_plugins) (sonar and IMU; see [step 3](https://github.com/BCLab-UNM/Swarmathon-ROS/blob/master/README.md#3-install-additional-gazebo-plugins) of the Quick Start guide).
-- ```mobility```: The top-level controller class for the physical and simulated robots. This package receives messages on the status of targets and/or obstacles in front of the robot and autonomously makes decisions based on these factors. This packages also receives pose updates from [robot_localization](http://wiki.ros.org/robot_localization) (see [step 2](https://github.com/BCLab-UNM/Swarmathon-ROS/blob/master/README.md#2-install-additional-ros-plugins) of the Quick Start guide) and commands from [joystick_drivers](http://wiki.ros.org/joystick_drivers) (see [step 3](https://github.com/BCLab-UNM/Swarmathon-ROS/blob/master/README.md#3-install-additional-gazebo-plugins) of the Quick Start guide).
-- ```obstacle_detection```: A logic processor that converts sonar signals into a ternary collision value. This package receives sonar messages from ```abridge``` (for physical robots) or [hector_gazebo_ros_sonar](http://wiki.ros.org/hector_gazebo_plugins) (for simulated robots), and returns a status message to differentiate between three possible cases:
-  1. No collision
-  2. A collision on the right side of the robot
-  3. A collision in front or on the left side of the robot
+- ```abridge```: A serial interface between Swarmathon-ROS and the A-Star 32U4 microcontroller onboard the physical robot. In the Swarmathon-ROS simulation, ```abridge``` functionality is supplanted by [gazebo_ros_skid_steer_drive](http://docs.ros.org/kinetic/api/gazebo_plugins/html/classgazebo_1_1GazeboRosSkidSteerDrive.html) (motor and encoders) and [hector_gazebo_plugins](http://wiki.ros.org/hector_gazebo_plugins) (sonar and IMU; see [step 3](https://github.com/BCLab-UNM/Swarmathon-ROS/blob/master/README.md#3-install-additional-gazebo-plugins) of the Quick Start guide).
+- ```behavours```: The top-level controller class for the physical and simulated robots. This package receives messages from sensors and implements behaviours the robot should follow in response. This packages also receives pose updates from [robot_localization](http://wiki.ros.org/robot_localization) (see [step 2](https://github.com/BCLab-UNM/Swarmathon-ROS/blob/master/README.md#2-install-additional-ros-plugins) of the Quick Start guide) and commands from [joystick_drivers](http://wiki.ros.org/joystick_drivers) (see [step 3](https://github.com/BCLab-UNM/Swarmathon-ROS/blob/master/README.md#3-install-additional-gazebo-plugins) of the Quick Start guide).
 - ```rqt_rover_gui```: A Qt-based graphical interface for the physical and simulated robots. See [How to use Qt Creator](https://github.com/BCLab-UNM/Swarmathon-ROS/blob/master/README.md#how-to-use-qt-creator-to-edit-the-simulation-gui) for details on this package.
-- ```target_detection```: An image processor that detects [AprilTag](https://april.eecs.umich.edu/wiki/index.php/AprilTags) fiducial markers in the onboard camera's video stream. This package receives images from the ```usbCamera``` class (for physical robots) or [gazebo_ros_camera](http://docs.ros.org/indigo/api/gazebo_plugins/html/classgazebo_1_1GazeboRosCamera.html) (for simulated robots), and, if an AprilTag is detected in the image, returns the integer value encoded in the tag.
+- ```target_detection```: An image processor that detects [AprilTag](https://april.eecs.umich.edu/wiki/index.php/AprilTags) fiducial markers in the onboard camera's video stream. This package receives images from the ```usbCamera``` class (for physical robots) or [gazebo_ros_camera](http://docs.ros.org/kinetic/api/gazebo_plugins/html/classgazebo_1_1GazeboRosCamera.html) (for simulated robots), and, if an AprilTag is detected in the image, returns the integer value encoded in the tag.
 - ```ublox```: A serial interface to the ublox GPS receiver onboard the physical robot. This package is installed as a git submodule in the Swarmathon-ROS repo. See the [ublox ROS wiki page](http://wiki.ros.org/ublox) for more information.
 
 ### How to use Qt Creator to edit the simulation GUI

apriltags_ros/.gitignore

@@ -0,0 +1,2 @@
+*~
+*.pyc

apriltags_ros/.travis.yml

@@ -0,0 +1,26 @@
+language:
+  - cpp
+compiler:
+  - gcc
+
+branches:
+  only:
+    - hydro-devel
+
+install:
+  - sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu precise main" > /etc/apt/sources.list.d/ros-latest.list'
+  - wget http://packages.ros.org/ros.key -O - | sudo apt-key add -
+  - sudo apt-get update -qq
+  - sudo apt-get install python-catkin-pkg python-rosdep ros-hydro-catkin -qq
+  - sudo rosdep init
+  - rosdep update
+  - mkdir -p /tmp/ws/src
+  - ln -s `pwd` /tmp/ws/src/package
+  - cd /tmp/ws
+  - rosdep install --from-paths src --ignore-src --rosdistro hydro -y
+
+script:
+  - source /opt/ros/hydro/setup.bash
+  - catkin_make
+  - catkin_make install
+  - source install/setup.bash

apriltags_ros/README.md

@@ -0,0 +1,4 @@
+apriltags_ros  [![Build Status](https://api.travis-ci.org/RIVeR-Lab/apriltags_ros.png)](https://travis-ci.org/RIVeR-Lab/apriltags_ros)
+=============
+
+AprilTags for ROS

apriltags_ros/apriltags/CHANGELOG.rst

@@ -0,0 +1,33 @@
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Changelog for package apriltags
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+0.1.2 (2016-07-06)
+------------------
+
+0.1.1 (2014-11-14)
+------------------
+* Updated author and website
+* Contributors: Mitchell Wills
+
+0.1.0 (2014-11-08)
+------------------
+* Updated dependancies for indigo
+* Contributors: Mitchell Wills
+
+0.0.3 (2014-11-08)
+------------------
+* Added info to package.xml
+* Added libv4l-dev as a dependancy
+* Contributors: Mitchell Wills
+
+0.0.2 (2014-10-31)
+------------------
+* Did some small cleanup and renaming to topics
+  Added the package ros wiki urls
+  Added example launch file
+* Contributors: Mitchell Wills
+
+0.0.1 (2014-10-27)
+------------------
+* Initial Commit from release r30 in https://svn.csail.mit.edu/apriltags

apriltags_ros/apriltags/CMakeLists.txt

@@ -0,0 +1,51 @@
+cmake_minimum_required(VERSION 2.8.3)
+project(apriltags)
+
+## Find catkin macros and libraries
+## if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz)
+## is used, also find other catkin packages
+find_package(catkin REQUIRED COMPONENTS cmake_modules
+)
+
+find_package(Eigen REQUIRED)
+find_package(OpenCV REQUIRED)
+
+catkin_package(
+  INCLUDE_DIRS include
+  LIBRARIES apriltags
+  CATKIN_DEPENDS
+  DEPENDS Eigen OpenCV
+)
+
+include_directories(include include/AprilTags)
+include_directories(
+  ${Eigen_INCLUDE_DIRS}
+  ${OpenCV_INCLUDE_DIRS}
+  ${catkin_INCLUDE_DIRS}
+)
+
+add_library(apriltags
+  src/Edge.cc src/FloatImage.cc src/GLine2D.cc src/GLineSegment2D.cc src/Gaussian.cc src/GrayModel.cc src/Homography33.cc src/MathUtil.cc src/Quad.cc src/Segment.cc src/TagDetection.cc src/TagDetector.cc src/TagFamily.cc src/UnionFindSimple.cc
+)
+target_link_libraries(apriltags
+  ${Eigen_LIBRARIES}
+  ${OpenCV_LIBRARIES}
+  ${catkin_LIBRARIES}
+)
+
+#############
+## Install ##
+#############
+
+## Mark executables and/or libraries for installation
+install(TARGETS apriltags
+  ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+  LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+  RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+)
+
+## Mark cpp header files for installation
+install(DIRECTORY include/
+  DESTINATION ${CATKIN_GLOBAL_INCLUDE_DESTINATION}
+  FILES_MATCHING PATTERN "*.h"
+)