In this tutorial we will show you how to programs robot behaviour on using Live Robot Programming over PhaROS.

Setup

  1. Follow the steps 1 to 4 of this post.
  2. Create a ROS node that consumes /kompai2/pose and /kompai/scan and publish in /command_velocity. To do this, just executing this:

    LrpharosPackage uniqueInstance
    
  3. Create an instance of the RobulabBridge class

    RobulabBridge uniqueInstance
    
  4. To assure that everything is fine, inspect the instance of RobulabBridge and check that its instance variable laserData is not nil and its values change over the time.
  5. Open the LRP UI by right-clicking the World and selecting Live Robot Programming.

Stop when an obstacle is detected

  1. Ok, so now we can start writing the behavior. First we will need some variables, those are: robulab to manage the robot and some constants such as: f_vel as linear velocity, t_vel for angular velocity, and min_distance as the minimum distance between the robot and an obstacle.

    (var robulab := [RobulabBridgr uniqueInstance ])
    (var min_distance := [0.5])
    (var f_vel := [0.25])
    (var t_vel := [0.5])
    
  2. We define the state machine called Tito.
    What we want to the robot is to go forward unless there is an obstacle in front of it so it should stop and turn to avoid it.
    This could be modelled in a abstractly as two states: forward and avoid.

    (machine Tito
        ;; States
        (state forward
            (onentry [robulab value forward: f_vel value])
        )
        (state stop
            (onentry [robulab value stop])
        )
    
        ;; Transitions
        (on obstacle forward -> stop t-avoid)
        (on noObstacle avoid -> forward t-forward)
    
        ;; Events
        (event obstacle [robulab value isThereAnObstacle: min_distance value])
        (event noObstacle [(robulab value isThereAnObstacle: min_distance value) not])
    )
    
  3. Finally, to run it, just start the machine on the forward state.
    (spawn Tito forward)

  4. The robot should move linearly and stop when detects an obstacle.

Avoiding obstacles

Let’s add an avoiding behavior. A simple one might be turning until it detects there is no obstacle and go forward again.
Then a simple behavior that match the avoidance requisite is:

  • If the obstacle is in the left side of the front: turn right
  • If the obstacle is in the right side of the front: turn left.

RobotBridge provides two methods to detect obstacles on the left and right part of the front of the robot: RobotBridge>>isThereARightObstacle: and RobotBridge>>isThereALeftObstacle:
Then, the idea is to turn left if there is an obstacle in the front-right, or, turn right if there is an obstacle in the front-left.

  1. Add the following states

            (state turnLeft
                (onentry [robulab value turn: t_vel value])
            )
    
            (state turnRight
                (onentry [robulab value turn: t_vel value negated])
            )
    
  2. Add the corresponding transitions

            (on rightObstacle stop -> turnLeft t-lturn)
            (on leftObstacle stop -> turnRight t-rturn)
            (on noObstacle turnLeft -> stop t-tlstop)
            (on noObstacle turnRight -> stop t-trstop)
    
  3. And add the events

            (event rightObstacle [robulab value isThereARightObstacle: minDistance value])
            (event leftObstacle [robulab value isThereALeftObstacle: minDistance value])
    
  4. Now the robot will start turning to avoid the obstacle.

Note

Updated version of LRP it is not necessary to add value after a variable.
Then,

    (onentry [robulab value turn: t_vel value negated])

is turned to

    (onentry [robulab turn: t_vel negated])

making it more readable.

As i already shout in the FOSDEM 2014 slides post, i have presented PhaROS in the last edition of FOSDEM, under the title of PhaROS: Towards Live Environments in Robotics.

I bring now to you this video taken during the presentation. I wish you to enjoy it!

Sorry if my hair is disheveled :), i am not very photogenic.

http://mirror.as35701.net/video.fosdem.org/2014/K4401/Saturday/PhaROS.webm

 

Enjoy it!

 

 

 

PhaROS has being in this last edition of FOSDEM (2014) we are proud to share our time and space with a lot of open source projects. Thank you very much for good feelings, feedback and sharing this amazing time.
Video and photos from this great event will be soon available here. Meanwhile, here are the slides

Keep tuned!

PhaROS tool has the mission of installing and creating packages into a ROS installation.

For doing this we have several commands, from installing and creating to administrating repositories, so you can manage your own packages and creating templates without major problems.

Install PhaROS tool

We are working for having this package in Ubuntu and ROS repositories, but meanwhile you can download it from here: pharos-deb

Once downloaded just execute

sudo dpkg -i pharos.deb

pharos –help

 

Install PhaROS based Package

pharos install PACKAGE [OPTIONS]

Example

pharos install esug –location=/home/user/ros/workspace –version=2.0

Help

pharos install –help

 Create PhaROS based Package

pharos create PACKAGE [OPTIONS]

Example

pharos create –location=/home/user/ros/workspace –version=2.0 –author=YourName –author-email=YourEmail

Tip: Be sure the email is a correct one. If is not a correctly spelled one you will notice during last step.
Help
pharos create –help

Register Repository of packages

pharos register-repository –url=anUrl –package=aPackage [ OPTIONS ]

Example

pharos register-repository –url=http://smalltalkhub.com/mc/user/YourProject/main –package=YourProjectDirectory –directory=YourProjectDirectory

Tip: If your repository requires user/password for reading add –user=User –password=Password to the example.
Disclaimer: User/Password will be stored in a text file without any security.
Help

pharos register-repository –help

Listing registered repositories

pharos list-repositories

Creating a directory for your own project repository

pharos create-repository PACKAGENAME [ OPTIONS ]

Example

pharos create-repository example –user=UserName > directory.st
pharos create-repository example –user=UserName  –output= directory.st

Help

pharos create-repository –help

 

 

 

We are now really glad to present an enhanced way to deal with PhaROS.

Since we want to keep with the ROS community spirit of collaborative development for robotics, we introduce now our own command for managing packages made in PhaROS.

This command is mean to install existing packages and create new packages with cool snippets and examples for going faster through the learning time.

PhaROS tool is made completely in Pharo smalltalk and it allows to deploy an existent package into a pharo 1.4/2.0/3.0 in any distribution of ROS that uses catkin package. It automatize the generation xml, makefiles, type and scripts creation, going on the direction of letting the pharo programmer to focus just in programming and not in infrastructure stuff.

For Installing and Using please check this post: using-pharos-tool

 

 

 

 

 

 

 

Since a bit more than one year of hard work, we are glad to be able to show the world our pharo client framework for ROS.

  ROS (Robot Operating System) provides libraries and tools to help software developers create robot applications. It provides hardware abstraction, device drivers, libraries, visualizers, message-passing, package management, and more. 

In order to make your life easy, we present here a virtualization with all the things needed installed and configured for the Groovy Galapagos version. Sadly, in this version of ROS (the last stable) the Gazebo simulator is not working, and also the most stable code of the previous version (Fuerte) is not working with gazebo anymore. Thats why the examples we show here are based on the easiest ROS simulator, the turtlesim.

We expect to be able to make a better showing up of all this world with the next version (Hydromedusa) which still unstable, but promise to have a whole new way to interact to simulators and so to let us show you a full simulated robot managed from your pharo image.

 

After you have downloaded the virtualization, and import it into your virtualbox installation, you need to get started into this new world. Remind always that currently, ROS is almost managed thought console commands, so, in order to interact with ROS and PhaROS you will need to use it, and of course, in order to use it you need to know some commands.

 

Yeah, cool, but you know, i just want to see something working, and i hate to waste my time understanding commands

So, open a terminal and execute:

rosrun esug pharos turtlesimpharo

 

Ok, you got my attention, i want to know a bit more about how to use ROS 

roscd {package name} ” This command step into the folder of the package ”

roscd esug ” This application will drive you to the esug package folder ”

rosrun { package name } { package-binary-name } { arguments } ” This command execute a binary of a package, generally this means a ROS Node that will have some responsibility”

rosrun esug pharos {script name} “punctually this command will execute a given script. ”
rosrun esug headless { script name } ” this command works like pharos command, but starts with a headless VM. Regard the inspects and halts before use this”
rosrun esug edit ” this command will open the image related without execute anything. This way, each package has its own image, and is easy to point to it and edit or browse it”
In order to change IP/Port of the ROS master, you need to change both, ~/.bashrc file (Changing the Environment variables) and also the constructors used by the scripts.

 

It is there any cheat sheet to have all the commands ? 

Yes of course: right here

 

Ok, i just execute the turtlesimpharo script, nice, there are more examples right? 

yes of course :), here you have an other one a bit more complex

rosrun esug turtlesimpursuitturtles

 

 Yeah! I love it, how do i make my own code?

A great way to begin is browsing PhaROSEsug package, it has commented methods and uses all the basic stuff. We will make some tutorials for advanced usage, but mean while you can have fun with that and browsing code and tests is always allowed ;).

 

 I made roscd esug, and i found a lot of folders! i don’t understand anything!

├── bin
│   ├── edit
│   ├── headless
│   └── pharos
├── build
├── CMakeLists.txt
├── ex.launch
├── image
│   ├── Pharo.changes
│   ├── PharoDebug.log
│   ├── Pharo.image
│   ├── PharoV10.sources
│   └── scripts
│   ├── turtlesimpharo
│   ├── turtlesimpursuitturtles
├── include
├── msg
├── package.xml
├── src
└── vm
└── pharo -> /home/pharos/vm/pharo

 

——————–
bin
——————–
we have the commands to interact with the related package-image

 

——————–
build
——————–
Is here to keep layout compatibility with ROS. Maybe will store package-cache in the future.

——————–
CMakeLists.txt
——————–
ROS give a make tool in order to generate infrastructure code, like the structures related with topic messages. Actually this file should be mantained by hand.
——————–
image
——————–
In this folder we encounter the related image, the common source/changes bundle, and the scripts folder

——————–
image/scripts
——————–

In this folder we have all the scripts that we can run with this package. This files are actually generated and related with script methods in the package-related-object in the image side. (To look for the object of esug package punctually, browse PhaROSEsug ).

 

——————–
include
——————–

This folder is for ROS layout compatibility. We are not currently using this folder.
——————–
msg
——————–
This folder is for message definition files ( .msg extention). This folder is mantained automatically with the type generation from image side, but you can also add your own types with no relation with the image side. In any case, messages and it dependancies should be updated in the ros infraestructure files (CMakeLists.txt, package.xml)
——————–
package.xml
——————–

This is the package description file that ROS use to define compile-time / runtime dependancies, author, etc. You should not worry about this file in any case but in the case of new types definition.

——————–
src
——————–
This folder is for ROS-fuerte layout compatibility. Is actually deprecated and it will be removed soon.
——————–
vm
——————–
This folder has the vm needed to run the exisiting image and code. Commonly is a symbolic link to the VM that the image creator of the package.
This folder and vm are usually pointed by the scripts at the bin folder.

 

 

 

 

 

 

In the RoboShop project, we aim at developing a platform for robotic applications in a shopping mall. We took the decision to use ROS, the robotic middleware backed by the Open Source Robotic Foundation. We also wanted to continue using our favorite language Pharo. This is how we end up developing PhaROS, a client for Pharo-based ROS nodes.

Today, we are glad to announce that the first version of PhaROS is now officially available, that is there is :

There is still much to do in PhaROS, and more broadly in the RoboShop project. But, so far we already have a PhaROS node that wraps the robot that we are using. We connected it to the gmapping SLAM algorithm and we have used it to buid a map of our lab. More to come soon.