MATLAB© is a programming language and environment designed for scientific computing. It is one of the best languages for developing robot control algorithms and is widely used in the research community. While it is often thought of as an offline programming language, there are several ways to interface with it to control robotic hardware ‘in the loop’. As part of our own development we surveyed a number of different projects that accomplish this by using a message passing system and we compared the approaches they took. This post focuses on bindings for the following message passing frameworks: LCM, ROS, DDS, and ZeroMQ.

The main motivation for using MATLAB to prototype directly on real hardware is to dramatically accelerate the development cycle by reducing the time it takes to find out out whether an algorithm can withstand ubiquitous real-world problems like noisy and poorly-calibrated sensors, imperfect actuator controls, and unmodeled robot dynamics. Additionally, a workflow that requires researchers to port prototype code to another language before being able to test on real hardware can often lead to weeks or months being lost in chasing down new technical bugs introduceed by the port. Finally, programming in a language like C++ can pose a significant barrier to controls engineers who often have a strong electro-mechanical background but are not as strong in computer science or software engineering.

We have also noticed that over the past few years several other groups in the robotics community also experience these problems and have started to develop ways to control hardware directly from MATLAB.

---

The Need for External Languages

The main limitation when trying to use MATLAB to interface with hardware stems from the fact that its scripting language is fundamentally single threaded. It has been designed to allow non-programmers to do complex math operations without needing to worry about programming concepts like multi-threading or synchronization. However, this poses a problem for real-time control of hardware because all communication is forced to happen synchronously in the main thread. For example, if a control loop runs at 100Hz and it takes a message ~8ms for a round-trip, the main thread ends up wasting 80% of the available time budget waiting for a response without doing any actual work.

A second hurdle is that while MATLAB is very efficient in the execution of math operations, it is not particularly well suited for byte manipulation. This makes it difficult to develop code that can efficiently create and parse binary message formats that the target hardware can understand. Thus, after having the main thread spend its time waiting for and parsing the incoming data, there may not be any time left for performing interesting math operations.

Figure 1. Communications overhead in the main MATLAB thread

Pure MATLAB implementations can work for simple applications, such as interfacing with an Arduino to gather temperature data or blink an LED, but it is not feasible to control complex robotic systems (e.g. a humanoid) at high rates (e.g. 100Hz-1KHz). Fortunately, MATLAB does have the ability to interface with other programming languages that allow users to create background threads that can offload the communications aspect from the main thread.

Figure 2. Communications overhead offloaded to other threads

Out of the box MATLAB provides two interfaces to other languages: MEX for calling C/C++ code, and the Java Interface for calling Java code. There are some differences between the two, but at the end of the day the choice effectively comes down to personal preference. Both provide enough capabilities for developing sophisticated interfaces and have orders of magnitude better performance than required. There are additional interfaces to other languages, but those require additional setup steps.

---

Message Passing Frameworks

Message passing frameworks such as Robot Operating System (ROS) and Lightweight Communication and Marshalling (LCM) have been widely adopted in the robotics research community. At the core they typically consist of two parts: a way to exchange data between processes (e.g. UDP/TCP), as well as a defined binary format for encoding and decoding the messages. They allow systems to be built with distributed components (e.g. processes) that run on different computers, different operating systems, and different programming languages.

The resulting systems are very extensible and provide convenient ways for prototyping. For example, a component communicating with a physical robot can be exchanged with a simulator without affecting the rest of the system. Similarly, a new walking controller could be implemented in MATLAB and communicate with external processes (e.g. robot comms) through the exchange of messages. With ROS and LCM in particular, their flexibility, wide-spread adoption, and support for different languages make them a nice starting point for a MATLAB-hardware interface.

---

Lightweight Communication and Marshalling (LCM)

LCM was developed in 2006 at MIT for their entry to DARPA’s Urban Challenge. In recent years it has become a popular alternative to ROS-messaging, and it was as far as we know the first message passing framework for robotics that supported MATLAB as a core language.

The snippet below shows how the MATLAB code for sending a command message could look like. The code creates a struct-like message, sets desired values, and publishes it on an appropriate channel.

%% MATLAB code for sending an LCM message
% Setup
lc = lcm.lcm.LCM.getSingleton();

% Fill message
cmd = types.command();
cmd.position = [1 2 3];
cmd.velocity = [1 2 3];

% Publish
lc.publish('COMMAND_CHANNEL', cmd);

Interestingly, the backing implementation of these bindings was done in pure Java and did not contain any actual MATLAB code. The exposed interface consisted of two Java classes as well as auto-generated message types.

• The LCM class provides a way to publish messages and subscribe to channels
• The generated Java messages handle the binary encoding and exposed fields that MATLAB can access
• The MessageAggregator class provides a way to receive messages on a background thread and queue them for MATLAB.

Thus, even though the snippet looks similar to MATLAB code, all variables are actually Java objects. For example, the struct-like command type is a Java object that exposes public fields as shown in the snippet below. Users can access them the same way as fields of a standard MATLAB struct (or class properties) resulting in nice syntax. The types are automatically converted according to the type mapping.

/**
 * Java class that behaves like a MATLAB struct
 */
public final class command implements lcm.lcm.LCMEncodable
{
    public double[] position;
    public double[] velocity;
    // etc. ...
}

Receiving messages is done by subscribing an aggregator to one or more channels. The aggregator receives messages from a background thread and stores them in a queue that MATLAB can access in a synchronous manner using aggregator.getNextMessage(). Each message contains the raw bytes as well as some meta data for selecting an appropriate type for decoding.

%% MATLAB code for receiving an LCM message
% Setup
lc = lcm.lcm.LCM.getSingleton();
aggregator = lcm.lcm.MessageAggregator();
lc.subscribe('FEEDBACK_CHANNEL', aggregator);

% Continuously check for new messages
timeoutMs = 1000;
while true

    % Receive raw message
    msg = aggregator.getNextMessage(timeoutMs);

    % Ignore timeouts
    if ~isempty(msg)

        % Select message type based on channel name
        if strcmp('FEEDBACK_CHANNEL', char(msg.channel))

            % Decode raw bytes to a usable type
            fbk = types.feedback(msg.data);

            % Use data
            position = fbk.position;
            velocity = fbk.velocity;

        end

    end
end

The snippet below shows a simplified version of the backing Java code for the aggregator class. Since Java is limited to a single return argument, the getNextMessage call returns a Java type that contains the received bytes as well as meta data to identify the type, i.e., the source channel name.

/**
 * Java class for receiving messages in the background
 */
public class MessageAggregator implements LCMSubscriber {

    /**
     * Value type that combines multiple return arguments
     */
    public static class Message {

        final public byte[] data; // raw bytes
        final public String channel; // source channel name

        public Message(String channel_, byte[] data_) {
            data = data_;
            channel = channel_;
        }
    }

    /**
     * Method that gets called from MATLAB to receive new messages
     */
    public synchronized Message getNextMessage(long timeout_ms) {

		if (!messages.isEmpty()) {
		    return messages.removeFirst();
        }

        if (timeout_ms == 0) { // non-blocking
            return null;
        }

        // Wait for new message until timeout ...
    }

}

Note that the getNextMessage method requires a timeout argument. In general it is important for blocking Java methods to have a timeout in order to prevent the main thread from getting stuck permanently. Being in a Java call prohibits users from aborting the execution (ctrl-c), so timeouts should be reasonably short, i.e., in the low seconds. Otherwise this could cause the UI to become unresponsive and users may be forced to close MATLAB without being able to save their workspace. Passing in a timeout of zero serves as a non-blocking interface that immediately returns empty if no messages are available. This is often useful for working with multiple aggregators or for integrating asynchronous messages with unknown timing, such as user input.

Overall, we thought that this was a well thought out API and a great example for a minimum viable interface that works well in practice. By receiving messages on a background thread and by moving the encoding and decoding steps to the Java language, the main thread is able to spend most of its time on actually working with the data. Its minimalistic implementation is comparatively simple and we would recommend it as a starting point for developing similar interfaces.

Some minor points for improvement that we found were:

• The decoding step fbk = types.feedback(msg.data) forces two unnecessary translations due to msg.data being a byte[], which automatically gets converted to and from int8. This could result in a noticeable performance hit when receiving larger messages (e.g. images) and could be avoided by adding an overload that accepts a non-primitive type that does not get translated, e.g., fbk = types.feedback(msg).
• The Java classes did not implement Serializable, which could become bothersome when trying to save the workspace.
• We would prefer to select the decoding type during the subscription step, e.g., lc.subscribe(‘FEEDBACK_CHANNEL’, aggregator, ‘types.feedback’), rather than requiring users to instantiate the type manually. This would clean up the parsing code a bit and allow for a less confusing error message if types are missing.

---

Robot Operating System (ROS)

ROS is by far the most widespread messaging framework in the robotics research community and has been officially supported by Mathworks’ Robotics System Toolbox since 2014. While the Simulink code generation uses ROS C++, the MATLAB implementation is built on the less common RosJava.

The API was designed such that each topic requires dedicated publishers and subscribers, which is different from LCM where each subscriber may listen to multiple channels/topics. While this may result in potentially more subscribers, the specification of the expected type at initialization removes much of the boiler plate code necessary for dealing with message types.

%% MATLAB code for publishing a ROS message
% Setup Publisher
chatpub = rospublisher('/chatter', 'std_msgs/String');

% Fill message
msg = rosmessage(chatpub);
msg.Data = 'Some test string';

% Publish
chatpub.send(msg);

Subscribers support three different styles to access messages: blocking calls, non-blocking calls, and callbacks.

%% MATLAB code for receiving a ROS message
% Setup Subscriber
laser = rossubscriber('/scan');

% (1) Blocking receive
scan = laser.receive(1); % timeout [s]

% (2) Non-blocking latest message (may not be new)
scan = laser.LatestMessage;

% (3) Callback
callback = @(msg) disp(msg);
subscriber = rossubscriber('/scan', @callback);

Contrary to LCM, all objects that are visible to users are actually MATLAB classes. Even though the implementation is using Java underneath, all exposed functionality is wrapped in MATLAB classes that hide all Java calls. For example, each message type is associated with a generated wrapper class. The code below shows a simplified example of a wrapper for a message that has a Name property.

%% MATLAB code for wrapping a Java message type
classdef WrappedMessage

    properties (Access = protected)
        % The underlying Java message object (hidden from user)
        JavaMessage
    end

    methods

        function name = get.Name(obj)
            % value = msg.Name;
            name = char(obj.JavaMessage.getName);
        end

        function set.Name(obj, name)
            % msg.Name = value;
            validateattributes(name, {'char'}, {}, 'WrappedMessage', 'Name');
            obj.JavaMessage.setName(name); % Forward to Java method
        end

        function out = doSomething(obj)
            % msg.doSomething() and doSomething(msg)
            try
                out = obj.JavaMessage.doSomething(); % Forward to Java method
            catch javaException
                throw(WrappedException(javaException)); % Hide Java exception
            end
        end

    end
end

Due to the implementation being closed-source, we were only able to look at the public toolbox files as well as the compiled Java bytecode. As far as we could tell they built a small Java library that wrapped RosJava functionality in order to provide an interface that is easier to call from MATLAB. Most of the actual logic seemed to be implemented in MATLAB code, but we also found several calls to various Java libraries for problems that would have been difficult to implement in pure MATLAB, e.g., listing networking interfaces or doing in-memory decompression of images.

Overall, we found that the ROS support toolbox looked very nice and was a great example of how seamless external languages could be integrated with MATLAB. We also really liked that they offered a way to load log files (rosbags).

One concern we had was that there did not seem to be a simple non-blocking way to check for new messages, e.g., a hasNewMessage() method or functionality equivalent to LCM’s getNextMessage(0). We often found this useful for applications that combined data from multiple topics that arrived at different rates (e.g. sensor feedback and joystick input events). We checked whether this behavior could be emulated by specifying a very small timeout in the receive method (shown in the snippet below), but any value below 0.1s seemed to never successfully return.

---

Data Distribution Service (DDS)

In 2014 Mathworks also added a support package for DDS, which is the messaging middleware that ROS 2.0 is based on. It supports MATLAB and Simulink, as
well as code generation. Unfortunately, we did not have all the requirements to get it setup, and we could not find much information about the underlying implementation. After looking at some of the intro videos, we believe that the resulting code should look as follows.

%% MATLAB code for sending and receiving DDS messages
% Setup
DDS.import('ShapeType.idl','matlab');
dp = DDS.DomainParticipant

% Create message
myTopic = ShapeType;
myTopic.x = int32(23);
myTopic.y = int32(35);

% Send Message
dp.addWriter('ShapeType', 'Square');
dp.write(myTopic);

% Receive message
dp.addReader('ShapeType', 'Square');
readTopic = dp.read();

---

ZeroMQ

ZeroMQ is another asynchonous messaging library that is popular for building distributed systems. It only handles the messaging aspect, so users need to supply their own wire format. ZeroMQ-matlab is a MATLAB interface to ZeroMQ that was developed at UPenn between 2013-2015. We were not able to find much documentation, but as far as we could tell the resulting code should look similar to following snippet.

%% MATLAB code for sending and receiving ZeroMQ data
% Setup
subscriber = zmq( 'subscribe', 'tcp', '127.0.0.1', 43210 );
publisher = zmq( 'publish', 'tcp', 43210 );

% Publish data
bytes = uint8(rand(100,1));
nbytes = zmq( 'send', publisher, bytes );

% Receive data
receiver = zmq('poll', 1000); // polls for next message
[recv_data, has_more] = zmq( 'receive', receiver );

disp(char(recv_data));

It was implemented as a single MEX function that selects appropriate sub-functions based on a string argument. State was maintained by using socket IDs that were passed in by the user at every call. The code below shows a simplified snippet of the send action.

// Parsing the selected ZeroMQ action behind the MEX barrier
// Grab command String
if ( !(command = mxArrayToString(prhs[0])) )
	mexErrMsgTxt("Could not read command string. (1st argument)");

// Match command String with desired action (e.g. 'send')
if (strcasecmp(command, "send") == 0){
	// ... (argument validation)

	// retrieve arguments
	socket_id = *( (uint8_t*)mxGetData(prhs[1]) );
	size_t n_el = mxGetNumberOfElements(prhs[2]);
	size_t el_sz = mxGetElementSize(prhs[2]);
	size_t msglen = n_el*el_sz;

	// send data
	void* msg = (void*)mxGetData(prhs[2]);
	int nbytes = zmq_send( sockets[ socket_id ], msg, msglen, 0 );

	// ... check outcome and return
}
// ... other actions

---

Other Frameworks

Below is a list of APIs to other frameworks that we looked at but could not cover in more detail.

Project	Notes
RabbitMQ-Matlab-Client	Simple Java wrapper for RabbitMQ with callbacks into MATLAB
URBI (tutorial)	Seems to be deprecated

Lecturer Steffen Pfiffner of University of Weingarten in Germany is teaching ROS to 26 students at the same time at a very fast pace. His students, all of them within the Master on Computer Science of University of Weingarten, use only a web browser. They connect to a web page containing the lessons, a ROS development environment and several ROS based simulated robots. Using the browser, Pfiffner and his colleague Benjamin Stähle, are able to teach how to program with ROS quickly and to many students. This is what Robot Ignite Academy is made for.

“With Ignite Academy our students can jump right into ROS without all the hardware and software setup problems. And the best: they can do this from everywhere,” says Pfiffner.

Robot Ignite Academy provides a web service which contains the teaching material in text and video format, the simulations of several ROS based robots that the students must learn to program, and the development environment required to build ROS programs and test them on the simulated robot.

Student’s point of view

Students bring their own laptops to the class and connect to the online platform. From that moment, their laptop becomes a ROS development machine, ready to develop programs for many simulated real robots.

The Academy provides the text, the videos and the examples that the student has to follow. Then, the student creates her own ROS program and makes the robot perform a specific action. The student develops the ROS programs as if she is in a typical ROS development computer.

The main advantage is that students can use a Windows, Linux or Mac machine to learn ROS. They don’t even have to install ROS in their computers. The only prerequisite of the laptop is to have a browser. So students do not mess with all the installation problems that frustrate them (and the teachers!), especially when they are starting.

After class, students can continue with their learning at home, library or even the beach if there is a wifi available! All their code, learning material and simulations are stored online so they can access them from anywhere, anytime using any computer.

Teacher’s point of view

The advantage of using the platform is not only for the students but also for the teachers. Teachers do not have to create the material and maintain it. They do not have to prepare the simulations or work on multiple different computers. They don’t even have to prepare the exams!! (which are already provided by the platform).

So what are the teachers for?

By making use of the provided material, the teacher can concentrate on guiding the students by explaining the most confusing parts, answer questions, suggest modifications according to the level of each student, and adapt the pace to the different types of students.

This new method of teaching ROS is exploding among the Universities and High Schools that want to provide the latest and most practical teachings to their students. The method, developed by Robot Ignite Academy, combines a new way of teaching based on practice and an online learning platform. Those two points combined make the teaching of ROS a smooth experience and can potentially see the students’ knowledge base skyrocket.

As user Walace Rosa indicates in his video comment about Robot Ignite Academy:

It is a game changer [in] teaching ROS!

The method is becoming very popular in the robotics circuits too, and many teachers are using it for younger students. For example, High School Mundet in Barcelona is using it to teach ROS to 15 years old students.

Additionally, the academy provides a free online certification exam with different levels of knowledge certification. Many Universities are using this exam to certify that their students did learn the material since the exam is quite demanding.

Some examples of past events

•  1 week ROS course in Barcelona for SMART-E project team members. This is a private course given by Robot Ignite Academy at Barcelona for 15 members of the SMART-E project that need to be up to speed with ROS fast. From 8th to 12nd of May 2017
•  1 day ROS course for the Col·legi d’Enginyers de Barcelona. The 17th of May 2017.
•  3 months course for University of La Salle in Barcelona within the Master on Automatics, Domotics and Robotics. From 10th of May to 29th of June 2017.
•  1 weekend ROS course for teenagers in Bilbao, Spain. The 20th and 21st of May 2017.
•  We can also organize a special event like these for you and your team.

Helpful ROS videos

Would you like to make a robot to grasp something, but you think that is impossible to you just because you can’t buy a robot arm? I’m here to tell that you can definitely achieve this without buying a real robot. Let’s see how:

How is that possible?

The Smart Grasping Sandbox built by Shadow Robotics is now available for everybody on the ROS Development Studio – a system that allows you to create and test your robot programs through simulations using only a web browser.

Wait, what is the Smart Grasping Sandbox?

The Smart Grasping Sandbox is a public simulation for the Shadow’s Smart Grasping System with theUR10 robot from Universal Robots. It allows you to make a robot to grasp something without having to learn everything related to Machine Learning, and being available on the ROS Development Studio, it allows you to test it without the hassle of installing all the requirements.

As Ugo Cupcic said:

I don’t want to have to specify every aspect of a problem — I’d rather the system learn the best way to approach a given problem itself.

Using the Development Environment for Grasping

In order to user the Smart Grasping Sandbox on ROS Development Studio—also known as RDS—just go to http://rds.theconstructsim.com and Sign In. Once logged in, go to the Public Simulations, select the Smart Grasping Sandbox simulation and press the red Launch this simulation button.

After pressing the Launch this simulation, a new screen will appears asking you to select the launch file. Just keep the default main.launch and press the red run button.

After a few seconds, the simulation will be loaded and you will be able interact with the simulation.

Once the simulation is loaded, you can see the instructions about how to control it on the left side.

In the center you have the simulation itself, and on the right side you can see the Integrated Development Environment and the Web Shell that allows you to modify the code and send Linuxcommands to the simulation respectively.

You can modify, the simulation, the control programs or even create your own manipulation control programs, make the grasping system learn using deep learning or else. This is up to you as developer!

You can also see what the robot sees using the online ROS 3D Visualizer (RViz) typing the following command on the Web Shell:

$ rosrun rviz rviz

After running Rviz, you press the red Open ROS Graphic Tools button on the bottom left side of the system and a new tab should appear with Rviz.

Conclusion

Here we have seen how to use a simulation to programme a robot to grasp something.

The simulation uses ROS as the middleware to control the robot.

If you want to learn ROS or master your ROS Skills, we recommend you to give a try to Robot Ignite Academy.

If you are a robot builder and want to have your own simulation available for everybody on RDS, or you want to have a course specifically for your robot, contact us through the email info@theconstructsim.com.

Today we are looking at how to program your NAO Robot for Human Interaction. Watch the video and follow the steps below to get interactive with your robot pal!

1.  Create an animation of movements
   • Right click, select “Create a new box”
   • Select “Timeline”

We want the robot to do 3 things, a five high, a hello, and a goodbye move:

• On the Timeline Edit Box
  • Name: High Five
  • Image: Click “Edit”
    • On the Edit box image
    • Click “Browse” and select a file
  • Click “OK”

Now, as you can remember, if we take it to the box, we can get access to the NAO’s Timeline. Mine now is connected to the PC. So what I’m going to do is I’m going to set some points of the NAO to do some movements. As I have said before on one of my tutorial I’m going to make it set all the joints to the whole body.

We want to make him look like he is doing a high five:

• Right click the arm
  • Click “Stiffen chain on/off”
  • Raise his arm up
• Set joints and keyframe
  • Select “Arms”
• Click “Play” on the Motion Controller

That’s a quite quick high five actually. What we want to do is to actually give him a pause when he got his arm in the air. So, the way we do that is to copy and paste the keyframe.

Grab a few already built in animation, just to show you how much it works:

• Go to Motions>Animations
  • Drag a “Hello” box to the workspace
  • Drag a “Wipe Forehead” box for a goodbye move to the workspace

We want to hear him speak, so:

• Go to Voice
  • Drag a “Speech Recognition” box to the workspace
• Drag a “Switch Case”
  • Connect the “Speech Recognition” box to the “Switch Case” box
  • On the first case, write “Hello” and connect to the “Hello” box
  • On the second case, write “High Five” and connect it to the “High Five” box
  • On the third case, write “Goodbye” and connect it to the “Wipe Forehand” box
• Set parameters of Speech Recognition
  • Word list: Hi; High Five; Goodbye;
  • Play with the threshold to see what works better
  • Click “OK”

So there we have a speech recognition, he will listen to what I am saying and then we will act a motion. Now, what we need to do is to make sure that the robot doesn’t repeat it, so you know, it doesn’t loop back. Before we do that, we are going to:

• Drag 3 “Say” box to the workspace so he can  speak back to us
  • On the “Switch case”, connect the “Hello” case on the “Say” box
    • Localized Text
      • Change the language to English(United States)
      • Write “Hi” on the textbox
  • Connect the “High Five” case on the “Say (1)” box
    • Localized Text
      • Change the language to English(United States)
      • Write “High Five” on the textbox
  • Connect the “Goodbye” case on the “Say(2)” box
    • Localized Text
      • Change the language to English(United States)
      • Write “Goodbye” on the textbox

So, here’s what we are saying, he recognizes it, says a word and does an animation, now what we want to do is we don’t want him to loop, as in he keeps hearing the same sound and maybe he starts to hear himself and repeat himself, so to stop that we need to connect the end of the motion boxes back to the “Speech Recognition” box. A simple output to the input speech.

I am going to make a little change actually, instead of “Hello”, we should put “Hi” here and I’m going to put “Hi” in there which is already done because they have to match otherwise if it doesn’t match he won’t recognize it. So if he hit “Load”

Philip: High Five!

Nao: High Five!

Philip: Goodbye!

Nao: Goodbye!

Philip: Hi!

Nao: Hello!

Brilliant! So that looks likes he’s working very well, so again if we says “Hi”, “High Five” or “Good bye” then he will greet you. If you walk in to room and you say “Hi” to a robot, obviously, he will do his animation and say a speech. Here you can use your imagination and try different things, different animations.

If you liked this article, you may also enjoy these from Robo-Phil:

• Python programming your NAO robot
• Hard at work: A review of the Laevo Exoskeleton

See all the latest robotics news on Robohub, or sign up for our weekly newsletter.

Imagine how easy it would be to learn skating, if only it doesn’t hurt everytime you fall. Unfortunately, we, humans,  don’t have that option. Robots, however, can now “learn” their skills on a simulation platform without being afraid of crashing into a wall. Yes, “it learns“! This is possible with the reinforcement learning algorithms provided by OpenAI Gym and the ROS Development Studio.

You can now train your robot to navigate through an environment filled with obstacles just based on the sensor inputs, with the help of OpenAI Gym. In April 2016, OpenAI introduced “Gym”, a platform for developing and comparing reinforcement learning algorithms. Reinforcement learning is an area of machine learning that allows an intelligent agent (for example, robot) to learn the best behaviors in an environment by trial-and-error. The agent takes actions in an environment so as to maximize its rewards. We have deployed the gym_gazebo package from Erle Robotics. in the ROS Development Studio. It enables the users to test their reinforcement learning for their robots in Gazebo.

How to Train your Robot

Robot training to navigate through an environment with obstacles

In this example we will be seeing how a turtlebot is able to learn navigating through an environment without hitting an obstacle. The turtlebot will use a reinforcement learning method known as Q-learning.

There are four environments already available for the user to test their simulations with. These environments can be launched using the respective launch files:

• GazeboCircuitTurtlebotLidar_v0.launch
• GazeboCircuit2TurtlebotLidar_v0.launch
• GazeboRoundTurtlebotLidar_v0.launch
• GazeboMazeTurtlebotLidar_v0.launch

The images of the different environments are given below:

The various environments already available:

Circuit	Circuit2
Round	Maze

The user is requested to try out the existing environment before developing their own environments for training the robot. An environment is where the robot’s possible actions and rewards are defined. For example, in the available environments, there are three possible actions for the Turtlebot robot:

– Forward ( with a reward of 5 points)
– Left ( with a reward of 1 point)
– Right ( with a reward of 1 point)

If it collides into the walls, then the training episode ends (with a penalty of 200 points). The turtlebot has to learn to navigate through the environment, based on the rewards obtained from different episodes. This can be achieved using the Q-learning algorithm. Let us see, how it can be done using the ROS Development Studio.

Using the ROS Development Studio for training the robot

First, we have to set the path in the jupyter-notebook as given below:

import sys
sys.path.append("/usr/local/lib/python2.7/dist-packages/")
sys.path.append("/home/ubuntu/gym-gazebo")
sys.path.append("/home/user/catkin_ws/src/gym_construct/src")
%matplotlib inline


The python scripts in the folder gym_construct/src/ help us simulate the reinforcement learning techniques for a Turtlebot. Currently, the number of episodes has been set to 20.
Feel free to increase the number of episodes in the python scripts (usually up to 5000) to actually train the robot to navigate the environment completely.Run the  only the script corresponding to the environment:

Run the python corresponding to the environment:

## Circuit-2 Environment --> Q-learning
%run /home/user/catkin_ws/src/gym_construct/src/circuit2_turtlebot_lidar_qlearn.py


The robot undergoes several training episodes and each of these episodes are rewarded based on the number of steps taken by the robot before hitting the environment. We will be able to see that the robot incrementally increases its rewards over time compared to its previous versions. With a very large number of episodes, the robot will learn to navigate the environment without hitting the obstacle.

Plotting the learning curve of the robot

The machine learning algorithm generates the output files in the output directory specified in the python script file. In order to plot the curve, we run the display_plot.py. But before that, don’t forget to restart the kernel and set the path once again.

As the number of episodes increases, we will see that the robot’s mean rewards also increases. The user can choose his own robot, environments, action and rewards for testing his reinforcement learning algorithms in OpenAI Gym and RDS. Watch the video below for more on this.

Video describing the procedure to run OpenAI Gym on RDS

I hope you were able to follow the tutorial.  So, that’s all folks. It’s now up to you to develop and test reinforcement learning algorithms in OpenAI Gym and RDS.

Have fun training your robot!

A new book by Lentin Joseph, ROS Robotics Programming, outlines more than 14 robotics projects using ROS that can be engaged with without requiring a lot of hardware. The book starts with an introduction to ROS and its installation procedure. After discussing the basics, you’ll be taken through great projects such as building a self-driving car, an autonomous mobile robot, and image recognition using deep learning and ROS. You can find ROS robotic applications for beginner, intermediate, and expert levels inside.

This book is unique in that it focuses on ROS via the lens of robotics projects only. Lentin is the CEO/Founder of Qbotics Labs and the author of Learning Robotics using Python and Mastering ROS for Robotics Programming.

Below is an overview of the chapters in the book:

Chapter 1, Getting Started with ROS Robotics Application Development, is for absolute beginners to ROS. No need to worry if you don’t have experience in ROS; this chapter will help you give you an idea of the ROS software framework and its concepts.

Chapter 2, Face Detection and Tracking Using ROS, OpenCV and Dynamixel Servos, takes you through a cool project that you can do with ROS and the OpenCV library. This project basically creates a face tracker application in which your face will be tracked in such a way that the camera will always train on your face. We will use intelligent servos such as Dynamixel to rotate the robot on its axis.

Chapter 3, Building a Siri-Like Chatbot in ROS, is for those of you who want to make your robot interactive and intelligent without much hassle. This project creates a chatterbot in ROS that you can communicate with using text or speech. This project will be useful if you’re going to create social or service robots.

Chapter 4, Controlling Embedded Boards Using ROS, helps you build a robot using Arduino, an embedded compatible board, Raspberry Pi, or Odroid and an interface to ROS. In this chapter, you will see a wide variety of embedded boards and the interfacing projects made with them.

Chapter 5, Teleoperate a Robot Using Hand Gestures, will teach you how to build a gesture control device using Arduino and IMU. The gestures are translated into motion commands by ROS nodes.

Chapter 6, Object Detection and Recognition, has an interesting project for detecting objects. You will learn both 2D and 3D object recognition using powerful ROS packages.

Chapter 7, Deep Learning Using ROS and TensorFlow, is a project made using a trending technology in robotics. Using the TensorFlow library and ROS, we can implement interesting deep-learning applications. You can implement image recognition using deep learning, and an application using SVM can be found in this chapter.

Chapter 8, ROS on MATLAB and Android, is intended for building robot applications using ROS, Matlab, and Android.

Chapter 9, Building an Autonomous Mobile Robot, is about creating an autonomous mobile robot with the help of ROS. You can see how to use packages such as navigation, gmapping, and AMCL to make a mobile robot autonomous.

Chapter 10, Creating a Self-driving Car Using ROS, is one of the more interesting projects in this book. In this chapter, we will build a simulation of the self-driving car using ROS and Gazebo.

Chapter 11, Teleoperating Robot Using VR Headset and Leap Motion, shows you how to control a robot’s actions using a VR headset and Leap Motion sensor. You can play around with virtual reality (a trending technology these days).

Chapter 12, Controlling Your Robots over the Web, we will see how to build interactive web applications using rosbridge in ROS.

The book uses ROS Kinetic and Indigo installed on latest Ubuntu L.T.S 16.04.01. The codes are also compatible with ROS Jade.

A basic knowledge in R.O.S, GNU/Linux, and C++ programming concepts is recommended.

The book is published by PACKT and can be purchased at Amazon Global and PACKT Publishing.

*All images credit: ROBBO

30 teachers arrived, excited to learn. They rolled up their sleeves and placed laptops and Robot kits on the floor. The room filled with excitement (and laughter!) as everyone tried to come up with different solutions on how to create different programs. The results were hilarious; a robot inspired by Darth Vader, a robot that asked everyone to turn the lights off when it was too bright in the room, and a robot that tricked the teacher to leave the classroom during an exam.

Not bad for a day of “work!”

Training, like above, is what we’re all about at ROBBO. ROBBO is a fun and simple way for absolutely anyone to get introduced to the world of robotics and coding. As a part of one of our many projects, we organized a training weekend for the single purpose of introducing teachers to programming and robotics. The teachers started with simple exercises in RobboScratch, a visual programming environment; moving the character, creating series of multiple commands, and learning the advantages of the infinite loop when making programs.

So, what do we mean about classroom robotics? Our educational robotics consist of two different robots; the Robot kit and the Lab. Both robots are ideal for learning programming, robotics as well as skills in problem-solving, mathematics and physics while working in interactive teams. The Lab includes a microphone, LED-lights, light sensor and a slider and is great for experimenting with different elements such as sound or light and numeric values. Our other robot is the Robot kit, equipped with a motor, which is a fun way to explore everyday technology using a touch sensor, proximity sensor, light sensor, line sensors and an LED-light. Our robots are programmed in the visual programming environment RobboScratch, an adapted version of Scratch developed at MIT.

In our earlier example, teachers were divided into separate workshops, working in pairs, or teams of three. We believe it is important to communicate and discuss with others to better understand different programs and come up with alternative solutions if the program doesn’t work in the desired way. The workshops are all based on the exercises from our pedagogical guide, and teachers were given a copy of the guide for their own use. Our guide provides instructions and multiple exercise card (with solutions!) and is free to download here (http://robbo.world/support/).

Our teaching guide is for anyone who wants to learn the basics of programming with the help of ROBBO robotics and RobboScratch. Our pedagogical guide is a comprehensive educational tool with instructions, exercise cards and ideas for creating the ultimate learning experience. It has been developed together with Innokas Network at the University of Helsinki and Finnish teachers and students. The majority of the teachers that participated in the training had only limited knowledge of Scratch or Scratch Junior and, therefore, we started from the beginning.

The pedagogical guide includes an introduction to RobboScratch, Lab and Robot kit as well as up to 28 exercise cards to help you along the way. The exercises are designed to develop necessary programming skills step by step, teaching children to think logically as a software developer would do, which may also be useful in many everyday situations. These are, in particular, the ability to understand the whole, to split a problem into smaller parts, and to develop a simple program to perform an operation. In the initial exercises, students will make a program using a predefined model, but as the practice progresses, they will have more and more space for their own ideas.

By developing new skills, users are encouraged to plan and develop innovations in robotics. The training goal is to learn understand and use technology to invent something new. As the final assignment of the teachers’ training, we asked teachers to form teams of four and come up with a small prank using the different capabilities and sensors of either Robot kit or Lab or simultaneous use of both robots.

If you’d like to to learn more about ROBBO or download our free guide, visit our website: http://robbo.world/support/

Comments from teachers:

“The teaching guide is a great support when learning coding. And I can just hand out these ready-made exercise cards to my students as well!”

“The exercise in the guide are good for understanding the different possibilities you have with the robots, because when you start doing an exercise you come up with more ideas on how to develop a more complicated program.”

“The robots emphasized practicality in the learning process. In addition to programming, ROBBO teaches environmental studies and all-around useful skills, in particular when the exercises of the pedagogical guide are being utilized.”

If you’d like to learn more about classroom robotics, check out these articles:

• How to get started (and progress) in robotics: A quick guide for teens and adults
• Teaching the teachers: Study focuses on how teachers perceive educational robots in classrooms
• Jade Robot: Hands on STEM for kids and classrooms
• Classroom robotics: Motivating independent learning and discovery
• Classroom robots: A great way to get young people started

See all the latest robotics news on Robohub, or sign up for our weekly newsletter.

You probably know the Sphero robot. It is a small robot with the shape of a ball. In case that you have one, you must know that it is possible to control it using ROS, by installing in your computer the Sphero ROS packages developed by Melonee Wise and connecting to the robot using the bluetooth of the computer.

Now, you can use the ROS Development Studio to create ROS control programs for that robot, testing as you go by using the integrated simulation.

The ROS Development Studio (RDS) provides off-the-shelf a simulation of Sphero with a maze environment. The simulation provides the same interface as the ROS module created by Melonee, so you can test your develop and test the programs on the environment, and once working properly, transfer it to the real robot.

We created the simulation to teach ROS to the students of the Robot Ignite Academy. They have to learn ROS enough to make the Sphero get out of the maze by using odometry and IMU.

Using the simulation

To use the Sphero simulation on RDS go to rds.theconstructsim.com and sign in. If you select the Public simulations, you will quickly identify the Sphero simulation.

Press the red Play button. A new screen will appear giving you details about the simulation and asking you which launch file you want to launch. The main.launch selected by default is the correct one, so just press Run.

After a few seconds the simulation will appear together with the development environment for creating the programs for Sphero and testing them.

On the left hand side you have a notebook containing information about the robot and how to program it with ROS. This notebook contains just some examples, but it can be completed and/or modified at your will. As you can see it is an iPython notebook and follows its standard. So it is up to you to modify it, add new information or else. Remember that any change you do to the notebook will be saved in a simulation in your private area of RDS, so you can come back later and launch it with your modifications.

You must know that the code included in the notebook is directly executable by selecting the cell of the code (do a single click on it) and pressing the small play button at the top of the notebook. This means that, once you press that button, the code will be executed and start controlling the Sphero simulated robot for a few time-steps (remember to have the simulation activated (Play button of the simulation activated) to see the robot move).

On the center area, you can see the IDE. It is the development environment for developing the code. You can browse there all the packages related to the simulation or any other packages that you may create.

On the right hand side, you can see the simulation and beneath it, the shell. The simulation shows the Sphero robot as well as the environment of the maze. On the shell, you can issue commands in the computer that contains the simulation of the robot. For instance, you can use the shell to launch the keyboard controller and move the Sphero around. Try typing the following:

• $ roslaunch sphero_gazebo keyboard_teleop.launch

Now you must be able to move the robot around the maze by pressing some keys of the keyboard (instructions provided on the screen).

You can also launch there Rviz, and then watch the robot, the frames and any other additional information you may want of the robot. Type the following:

• $ rosrun rviz rviz

Then press the Screen red icon located at the bottom-left of the screen (named the graphical tools). A new tab should appear, showing how the Rviz is loading. After a while, you can configure the Rviz to show the information you desire.

There are many ways you can configure the screen to provide more focus to what interests you the most.

To end this post, I would like to indicate that you can download the simulation to your computer at any time, by doing right-click on the directories and selecting Download. You can also clone the The Construct simulations repository to download it (among other simulations available).

If you liked this tutorial, you may also enjoy these:

• UgCS photogrammetry technique for UAV land surveying missions
• Programming for robotics: Introduction to ROS
• Python programming your NAO robot
• Robotics, maths, python: A fledgling computer scientist’s guide to inverse kinematics
• 3-D printing hydraulically-powered robots, no assembly required

See all the latest robotics news on Robohub, or sign up for our weekly newsletter.

This handy video-tutorial course gives an introduction to the Robot Operating System (ROS), including many of the available tools that are commonly used in robotics. With the help of different examples, the tutorials offer a great starting point to learn programming robots. You will learn how to create software including simulation, to interface sensors and actuators, and to integrate control algorithms.

The course consists of a guided tutorial and exercises with increasing level of difficulty working with an autonomous robot. We provide recordings of the lectures and give an introduction to the exercises. From the course website, you can download all the material including exercise sheets and templates, and use the provided Virtual Machine (VM) image to start programming right away.

Objectives:

• ROS architecture: Master nodes, topics, messages, services, parameters and actions
• Console commands: Navigating and analyzing the ROS system and the catkin workspace
• Creating ROS packages: Structure, launch-files, and best practices
• ROS C++ client library (roscpp): Creating your own ROS C++ programs
• Simulating with ROS: Gazebo simulator, robot models (URDF) and simulation environments (SDF)
• Working with visualizations (RViz) and user interface tools (rqt)
• Inside ROS: TF transformation system, time, bags

Course 1:

Course 2:

Course 3:

Course 4:

Download the full presentation here.

P. Fankhauser, D. Jud, M. Wermelinger, M. Hutter, “Programming for Robotics – Introduction to ROS”, ETH Zurich, 2017. DOI: 10.13140/RG.2.2.14140.44161

If you liked this tutorial, you may also enjoy these:

• Python programming your NAO robot
• Robotics, maths, python: A fledgling computer scientist’s guide to inverse kinematics
• Sticky business: Five adhesives tested for 3D printing
• Adjust how you learn and quickly pick up robotics programming
• 3-D printing hydraulically-powered robots, no assembly required

See all the latest robotics news on Robohub, or sign up for our weekly newsletter.

Tutorial 1: Speech

Helpful hints:

Follow these steps to create a box that we could put our python code into, and have our robot speak: “Hello”. “Hello I am a robot”.

1. Right click the main section box and go to “add new box”
2. Create a name for the box
3. Input main image
4. Select the type of box

Now we’re having a look at the script. Go into the scripts and click ok. And there we have our NAO little box. If we click into it, we have the python code. What we are going to do is change some of the codes to get our robot to speak.

1. Double click the box
2. Select the piece of code you need to alter to get our robot to speak(“def onInput_onStart(self)”)
3. Take out the pass section
4. Type in “ttsproxy = ALProxy(“ALTextToSpeech”)”. (Make sure you get the comment in there).
5. Underneath that, we are going to put “ttsproxy.say” and add the comment “Hello, I am a robot”.

The first line could create an object that gives us access to the robot’s text to speech capabilities. This object is assigned to the variable ttsProxy. We can access the object later through the name ttsProxy. I am going to mount the top line, and the alspeech is there. The second line calls a different function site. This function takes an argument “Hello, I am a robot” and then he uses a string or sequence of characters between two double quoted marks. The robot will speak the string that will pass to the say message aloud.  There are your simple first steps into python and choreograph.

You can now, hopefully, get your NAO robot to talk by using your python programming skills. Now have a play with it’s behavior to see if you can get your NAO to say a longer sentence, or maybe even sing a song. Have a play, and use your imagination!

Tutorial 2: Walking

Helpful hints:

No we’re going get your robot to walk using Python. The NAO can be program to walk to any point using the in-build Python Programming Language instead of using the drag and drop boxes in the choregraphe. Python is more expressive and allows you to do things like computing trigonometric calculations on the robot.

1. Right click the main section box and go to “add new box”
2. Create a name for the box
3. Input main image
4. Select the type of box

First, we want our robot to stand up. Drag a stand up icon into the box. I am actually using the NAO key so the 3D robot in the robot view, and this because we need to put the robot on connecting so we can see what’s going on quite clearly. Oversee when you are using this on the real robot and never forget to trigger on the motors and connect everything up properly.

Open the Code Box

1. Go to “def onInput_onStart(self):”
2. Write “motionProxy = ALProxy(“ALMotion”)”
3. On the next line write “walkTo(0.2,0.0,0.0)”
4. End it with “self.onStopped()”

The first line is a proxy called ALmotion, which what is we created here, which allows us to call the motion functions up. The second line is the walkTo, which moves the robot to a specific distance. Now, look on the decimal places: see that .2 is X and Y and the radius, so he’s going to move .2 forward. Then if I start playing with the other numbers here, he’ll move to the Y radius and then to the other turning point as well. The final bit is the self.on. To stop this, we will call and tell the choregraphe to stop the procedure when it is at the end and just simple loop and loop and loop.

If we are good, we should see this now on the 3D NAO. So if I hit play, we can see it walking along. Well done guys, you can now get your NAO Robot to walk by using
your Python programming skills. Tread carefully!

If you liked this article, you may also enjoy these:

• Robotics, maths, python: A fledgling computer scientist’s guide to inverse kinematics
• Sticky business: Five adhesives tested for 3D printing
• Meet RoboGabby: She’s on a mission to teach more girls about robotics
• Adjust how you learn and quickly pick up robotics programming
• 3-D printing hydraulically-powered robots, no assembly required

See all the latest robotics news on Robohub, or sign up for our weekly newsletter.

Image: IEEE

On the 15th November 2016, the IEEE’s AI and Ethics Summit posed the question: “Who does the thinking?” In a series of key-note speeches and lively panel discussions, leading technologists, legal thinkers, philosophers, social scientists, manufacturers and policy makers considered such issues as:

• The social, technological and philosophical questions orbiting AI.
• Proposals to program ethical algorithms with human values to machines.
• The social implications of the applications of AI.

Click here to read the final report, and enjoy a selection of videos from the conference below.

Welcome: Marko Delimar
Keynote Speaker: Wojciech Wiewiórowski

Panel 1: Autonomous Systems – Managing Risk and Reward
Panel Members: Raja Chatila, Kay Firth-Butterfield, Juha Heikkilä, Jérôme Perrin

Panel 2: Programming Human Ethics: Cui Bono?
Panel Members: Joanna Bryson, Mady Delvaux, Sarah Spiekermann, Corrine Cath

Panel 3: Social Implications – Perils & Promises of AI
Panel Members: Greg Adamson, Nikolaos Mavridis, Paul Nemitz, Aurélie Pols

Closing Remarks: John C. Havens

You might also enjoy the following articles about AI and AI/robotics policy:

• MIT Media Lab to participate in $27 million initiative on AI ethics and governance
• How artificial intelligence is changing our Christmas shop
• White House report: Artificial intelligence, automation, and the economy
• White House launches public workshops on AI issues
• White House releases reports focusing on opportunities and challenges of AI

See all the latest robotics news on Robohub, or sign up for our weekly newsletter.

This book begins with a deep overview of the ROS framework, discusses robot manipulation and navigation, and covers how ROS interfaces with I/O boards, sensors, and actuators. Vision sensors are essential ingredients in robotics, and so an entire chapter is dedicated to how they interface with ROS. The book also explores hardware interfacing and the simulation of complex robots in ROS and ROS Industrial, and finishes with a chapter on best practices to follow while programming in ROS.

Below is an overview of the chapters in the book:

1. Introduction to ROS and its package management
2. Working with 3D robot modeling in ROS
3. Simulating  robots using ROS and Gazebo
4. Using the ROS MoveIt! and Navigation stack
5. Working with Pluginlib, Nodelets and Gazebo plugins
6. Writing ROS controllers and visualization plugin
7. Interfacing I/O boards, sensors and actuators to ROS
8. Programming Vision sensors using ROS, Open-CV and PCL
9. Building  and interfacing differential drive mobile robot hardware in ROS
10. Exploring the advanced capabilities of ROS MoveIt!
11. ROS for Industrial Robots
12. Troubleshooting and best practices in ROS

The book uses ROS Indigo installed on latest Ubuntu L.T.S 14.04.03. The codes are also compatible with ROS Jade. https://github.com/qboticslabs/mastering_ros

A basic knowledge in R.O.S, GNU/Linux, and C++ programming concepts is recommended.

The book is published by PACKT and can be purchased at Amazon Global  and PACKT Publishing. More information can be found on the book website and Wiki page.

If you liked this post, you may also be interested in:

• Learning robotics using Python
• Book Review: Implementation of Robot Systems, by Mike Wilson
• Arduino for Makers #2: Deconstructing Arduino programs
• Arduino for Makers #1: Setting up a development station
• MATLAB Robotics System Toolbox and ROS

See all the latest robotics news on Robohub, or sign up for our weekly newsletter.