AriaCoda

AriaCoda is a C++ library used to communicate with Pioneer and Pioneer-compatible mobile robot controllers, many sensors and other accessory devices, and includes various useful tools for mobile robotics applications.

The C++ code in AriaCoda is mostly C++03 and C with some C++11 and C++14 features used as well. It can be compiled with any C++ compiler supporting at least C++14. (In the future it may be updated to C++17 or C++20.)

AriaCoda is based on the prior open-source ARIA library (Copyright 2002, 2003, 2004, 2005 ActivMedia Robotics, LLC. Copyright 2006, 2007, 2008, 2009 MobileRobots Inc., Copyright 2010-2015 Adept Technology, Copyright 2016-2018 Omron Adept Technologies, Inc.)

AriaCoda is distributed under the terms of the GNU General Public License (GPL) version 2.

See LICENSE.txt for full license information about AriaCoda.

Requirements

AriaCoda is intended to be used on any recent standard Linux, MacOSX, Windows 7, or Windows 10 system. The only requirements are standard operating system libraries (POSIX, as well as the Windows C Runtime and Platform SDK if on Windows and some standard Linux libraries if on Linux).

See the section "Building AriaCoda" below for requirements to build AriaCoda from source code.

Major Changes from previous Aria releases

Several major changes have been made for AriaCoda since the last release of Aria 2.9 by Omron/Adept MobileRobots:

• All header files have been moved into an Aria subdirectory. All header file #include directives must be updated. For example, use #include "Aria/ArRobot.h" instead of #include "ArRobot.h".
• When installed on a Linux system, standard installation locations are used. See "Installation" below for details.
• ArNetworking is no longer included or installed with Aria
• Some classes have been removed (if obsolete, or only necessary for use with ArNetworking or used in non-open source products). Code for these classes has been moved into the attic subdirectory of the git repository. Removed classes include the following:
  • ArSimpleConnector (use ArRobotConnector, ArLaserConnector, and other connector classes instead.)
  • ACTS related classes
  • ArAMPTU, ArP2Arm, ArIrrfDevice, ArTCM2, ArSonyPTZ and ArVersalogicIO have been removed.
  • ArMode and subclasses, and all keyboard handling code, generally only used by examples/demo.cpp, has just been moved into examples/demo.cpp.
  • ArNetServer
  • Support classes for ArNetworking (ArDrawingData etc.)
  • some other classes have been removed as well.
• The list of sensor readings in ArRangeBuffer has been changed from a list of pointers to ArPoseWithTime objects (std::list<ArPoseWithTime*>) to simply a list of ArPoseWithTime objects (std::list<ArPoseWithTime>). ArRangeDevice:getCurrentBuffer() and ArRangeDevice::getCumulativeBuffer() have been replaced by getCurrentReadings() and getCumulativeReading() which return a const reference to the list instead of a pointer. This should make it a bit easier to work with range device data but will require changing any code that accesses it through these interfaces. (The old methods returning pointers have been retained as "Ptr" versions, but will be removed in the future.)
• ArLog default output type is now stderr instead of stdout.
• Many unnecessary uses of "virtual" method declaration (including destructors) have been removed. If you derive from any ARIA class and intend to override a method, the use of the "override" specifier is encouraged; the C++ compiler should then warn if the base class method is not virtual. If you encounter problems using AriaCoda because of this change, please submit a bug report in Github issues.
• Some function argument and return types have been changed from int to size_t or other more specific or appropriate type.
• The feature of ArFunctor subclasses to store parameter values and the various invoke() overloads that used them if too few arguments provided, has been deprecated. Future changes will probably remove this feature (or ArFunctor will be replaced entirely by standard C++ features.)
• Fixed width integer types aliased in the ArTypes (ArTypes::Byte, ArTypes::Byte2, ArTypes::Byte4, ArTypes::Byte8, ArTypes::UByte, ArTypes::UByte2, ArTypes::UByte4, ArTypes::Ubyte8) are deprecated. Use standard C++ fixed width integer types instead (std::int8_t, std::int16_t, std::int32_t, std::int64_t, std::uint8_t, std::uint16_t, std::uint32_t, std::uint64_t).
• ArMap::getMapObjects() has been changed to return a const reference (const std::list<ArMapObject*>&) rather than a pointer. Other accessors in ArMap have been made const. (Note, This may be further changed in the future
  to a list of ArMapObject objects or smart pointers rather than pointers.) ArMap::getMapObjectsPtr() has been added for internal use and as an easy compatibility function, but use outside of the library is deprecated.
• Various fixes and changes to improve optimization and conformance/correctness. Due to code removal, various optimizations in the source code (especially in frequently used storage and utility classes such as ArSensorReading, ArRangeBuffer, ArRangeDevice, ArPose, etc), and compilation optimizations turned on by default, the AriaCoda shared library should be slightly more efficient than previous versions of ARIA. Additional warning flags have been enabled during compilation, and some of the potential problems indicated by those warnings have been fixed. If any changes have introduced undetected bugs or unintentional changes in behavior, please report any problems on github issues.

Several other changes are planned that will not be compatible with prior Aria releases, see TODO.md.

AriaCoda defines the preprocessor symbols ARIACODA and ARIA_3 which may be used to perform conditional compilation in an application depending on whether ARIA 2.x or AriaCoda are being used.

Over time, the library may be more consistently modernized to C++17 or later (unless significant rewriting of generally working and stable code would be required). This may require further deprecating, removing or changing some interfaces. The biggest changes will likely be to replace ArFunctor, ArTime, and threading and other OS portability wrappers with newer C++ standards, and possibly requiring use of smart pointers especially when objects or references are passed into or out of the ARIA API, as well as more consistent use of e.g. std::string or std::string_view rather than char *, use of standard types rather than types defined by ARIA, etc. See TODO.md for details.

Support and Contributing

AriaCoda is not supported by Omron Corporation or any other commercial organization. There are many ways to help continued improvement and maintenance of AriaCoda:

• Report bugs or request improvements. Did you encounter documentation that is incorrect or difficult to understand? Would you like to see example code for a particular feature? Is there a bug or problem with AriaCoda? Report the issue here.
• Contribute improvements, bug fixes, tests, documentaton fixes, updated Visual C++ project files, etc.
  See TODO.md for ideas. Changes can be discussed on GitHub Issues.
• Financial sponsorship of the primary developer through GitHub Sponsorship or through other means. This will let me spend more time working on AriaCoda. Contact me to discuss further.

Building AriaCoda

The only requirements to build AriaCoda from source code are common developer tools, and a C++ compiler that supports C++14. There are no additional library dependencies.

On Linux, the GNU C++ compiler (g++/gcc), GNU Make, and standard shell tools are required. On Ubuntu or Debian Linux, run sudo apt install make g++ to install. (Clang can be used as well.) The C++ compiler must support at least C++14;
GCC 9 or later is recommended. (Ubuntu Bionic or later is recommended as Linux operating system.) See below for notes on older GCC/OS versions.

On Windows, Visual C++ 2019 is required to use the provided project and solution files. The free "Community" edition can be downloaded from http://visualstudio.microsoft.com/downloads. The core C++ development and Windows SDK components are required, no additional Visual Studio components are needed. See more build instructions below.

It is also possible to build AriaCoda with MinGW on Windows.

On Mac OSX, XCode and command-line development tools are required.
(Run XCode, open "Preferences" from the application menu, select "Downloads", select "Command Line Tools", and click "Install".) Run make from a Terminal shell.

In addition, some optional features have additional build requirements.

• Dox