Creating a CRAM package

Description: In this tutorial you will set up a ROS package to use the CRAM plan language within the repl.

Next Tutorial: Controlling turtlesim from Lisp_2

First we need to create a ROS package that depends on cram_language. You can do this with either catkin or rosbuild. On the Ros website there are two tutorials about creating a package: Package creation and Package creation by hand. It is recommended that you work with catkin. In the src subdirectory of your catkin workspace execute the following command:

$ catkin_create_pkg cram_beginner_tutorial cram_language 

If you have good reasons you can also follow the rosbuild instructions to create a package.

Setting up the Common Lisp part is a little bit more work. First we need to create a Lisp 'project file', i.e. an ASDF system. After that we will need to create a Common Lisp package (i.e. the equivalent to C++ namespaces). You can learn roslisp in more detail at the roslisp tutorial

Switch into the root directory of the cram_beginner_tutorial package and create a file cram-beginner-tutorial.asd. You shouldn't use underscores but dashes in .asd file names. The reason is that the system that is defined in the .asd file should be named like the file itself and in Lisp it is very uncommon to use underscores in general.

Put the following content into cram-beginner-tutorial.asd:

(defsystem cram-beginner-tutorial
  :depends-on (cram-language)
  :components
  ((:module "src"
            :components
            ((:file "package")
             (:file "tutorial" :depends-on ("package"))))))

The first line defines the name of the system. Then we specify the dependencies of the system, i.e. other systems that need to be loaded before we load our system.

Finally, we define the components of the system. A component is a sort of sub-system and might be either a module (i.e. a sub-directory) or a file. ASDF knows some more component types but they are not relevant for us most of the time. We define that the system knows a sub-directory src. Further, we define that this module contains two components, one file for the package definition package.lisp and one with the actual tutorial code tutorial.lisp that has exactly one dependency - the component package. We will create these two source files next. Dependencies inside the system can be any component that is known in the current scope. That means that a component can only depend on those components that are defined in the same parent component. Please note that the file extension must be left out when defining files.

Lisp packages are the equivalent to C++ namespaces or to Python modules. Lisp packages cannot be hierarchic. We can define which other packages should be used, i.e. which symbols should be accessible without a package prefix. Further, we can define which symbols should be exported from the package.

Create a sub-directory src in your package. Then create the file package.lisp and put the following code into it:

(defpackage cram-beginner-tutorial
  (:nicknames :tut)
  (:use #:cpl))

We define a package with the name cram-beginner-tutorial. Packages in Common Lisp can have an arbitrary number of nicknames. In our case we nickname cram-beginner-tutorial as tut. Finally, we define that the package uses another package cpl which is a nickname of the package CRAM Plan Language. <!–Please note that most Common Lisp packages actually use the package common-lisp which exports all symbols of the Common Lisp standard. The packages cpl and common-lisp cannot be used together because the CRAM Language re-defines some of the symbols of the common-lisp package and thus cpl and common-lisp would conflict.

We have to deside how much lisp content we want to have in here. –>

To actually load the ASDF system, all files referenced in the system definition must be present and we are missing the file tutorial.lisp in src, so create it with the following content:

(in-package :tut)

This just selects the namespace of the file by the nickname :tut we defined in package.lisp. We will fill it with more content in later tutorials.

Now we are ready to compile and load our new system. Launch the Lisp REPL. If it is already running, reload it by executing:

,
restart-inferior-lisp

in the REPL. Then load your newly created system by typing:

(ros-load:load-system "cram_beginner_tutorial" :cram-beginner-tutorial)

<!–You need to load the system every time before you use it, so experts would build their own shortcuts to this command or use the rosemacs function unstead:

,
ros-load-system
cram_beginner_tutorial
cram-beginner-tutorial

The first parameter to ros-load-system names the ROS package in which to search for the system, the second parameter names the system to be loaded. Executing the above command should load our new ASDF system. –> Now the package cram-beginner-tutorial should be defined. Test it by evaluating

(in-package :tut)

Now that we have created our first CRAM package, let's try controlling the ROS turtlesim from it…

Controlling turtlesim from Lisp_2