Open Robots with Open Roberta

Kids, and Hackaday editors, love robots! The Open Roberta project (OR) takes advantage of this to teach kids about programming. And while the main focus is building a robot programming language that works for teaching grade-school and high-school kids, it’s also a part of a large open source robotics ecosystem that brings a lot more to the table than you might think. We talked with some folks at Google, one of the projects’ sponsors, about where the project is and where it’s going.

csm_Roberta_9e1215fc57Building a robot can be very simple — assembling pre-configured parts or building something small, quick, and cute — or it can be an endeavour that takes years of sweat and tears. Either way, the skills involved in building the ‘bot aren’t necessarily the same as those it takes to program the firmware that drives it, and then eventually the higher-level software that makes it functional and easy to drive.

OR, as an educational project, makes it very, very easy for kids to start off programming robots, but it’s expandable as the user gets more experienced. And since everything is open source, it’s part of a whole ecosystem that makes it even more valuable. We think it’s worth a look (along with something significantly more complex like ROS) if you’re playing around with robotics.

System Architecture

openRoberta.dotOpen Roberta is the user-facing middleware in a chain of software and firmware bits that make a robot work in a classroom environment. For the students, everything runs inside a browser. OR provides a webserver, robot programming interface and language, and then converts the output of the students’ programs to something that can be used with the robots’ firmware. The robots that are used in classrooms are mostly based on the Lego Mindstorms EV3 platform because it’s easy to put something together in short order. (But if you don’t have an EV3, don’t despair and read on!)

The emphasis is on ease of entry for the students and the teachers supervising the class. Everything runs in a browser, so there’s nothing to install on the client side. The students connect to a server that directs the robots, communicating with the robots’ own operating system, and uploading the students’ programs.

NEPO

inputParameter_animatedTo program the ‘bots in a browser, everything is written in a graphical programming language, NEPO which is pretty slick. (It’s also “open” spelled backwards. Sigh.) It’s based on Google’s blockly visual programming editor. You drag around blocks that correspond to sensors or loops or test conditions, and can assemble fairly complicated programs without typing a word of code. Which means that it frees young’uns from the pitfalls of “real” programming, like forgotten semicolons or mismatched parentheses. Instead, they get the abstractions without the syntactic hassles.

The blocks are broken into beginner blocks, which make the simulated (and real) robots into essentially a LOGO turtle, albeit one with a decent array of sensors. Opening up the box of “expert” blocks brings in standard programming constructs like functions, lists, and messages that allow the robots to talk to one another. In the end, it’s a decently rich programming environment, but it’s also one that has a very low barrier to entry.

The design of the blocks themselves is a major contribution to the ease of use of the system. For instance, instead of controlling the wheel motors directly, the motor blocks take information about the robot’s wheel diameter and track width, which makes it easy to turn the robot by 90 degrees.

The or_labsserver also runs a simulation of the robot, complete with obstacles and color tiles to sense, so the students can try their code out on a simulator before sending it to the actual physical robot for execution where it will run just like it did in simulation. (Or the students will learn a valuable lesson.) This unification of the simulation environment and the robot’s code is brand new, coming out in the last revision of Open Roberta Lab.

Of course, if you’re a single user, you can also install the OR server on your own laptop and use it locally, with your browser connecting to a webserver that’s run off the same machine. Or run it on a Raspberry Pi.

The Bots

On the other end, the robots originally ran on Lego’s EV3 platform running LeJOS, a Java-based environment. But recently, OR has been extended to connect up with ev3dev which is a more recent Debian-flavored Linux distribution. Both OSes can be downloaded to an SD card and simply slotted into your EV3 if you’ve got one. In the case of the LeJOS target, the NEPO code is turned into Java, and for ev3dev, it’s converted to Python. LeJOS is older and more stable, while ev3dev is newer, starts up faster, and appears to be getting hacked to work on other platforms.

logo_ev3dev_monoAnd that’s where things start to get even more interesting for us. We just started digging into ev3dev for this article, but it looks impressive. It’s got a lot more features than Open Roberta supports at the moment, from more sophisticated motor control to a much wider variety of sensors supported. For instance, it works with the XV11 lidar unit that we’ve showcased in the past. And although development has focused on the EV3 platform, there is recent support for the Raspberry Pi and BeagleBone. If we had a Pi-based robotics platform to try it out on, you’d be reading a review of ev3dev next week. Instead, why not browse their tutorials? Have any of you used it?

Wrapup

Open Roberta is interesting enough as a teaching tool for luring young kids into programming by giving them something tangible to move around — it’s a Turtle bot for the 2010’s with a lot more bells and whistles and a significantly richer programming language. But the fact that it’s entirely open source and moving toward a broader range of robotics platforms based on common single-board Linux computers makes it even more useful.

The Open Roberta team is very open to deploying on new hardware systems; they’re even thinking about adding an Arduino-based robot platform. So if you’re interested in getting a nicely-done higher-level interface for your own robot, even if just for use in the testing phases, you could do a lot worse than to make it interoperable with their ecosystem, either by hooking into OR directly or by using something like e3dev for your robot’s brain. You can hook up with the Open Roberta team via IRC on freenode.net in #open-roberta.

10 thoughts on “Open Robots with Open Roberta

  1. Read this post rather quickly,
    but does it look at toward programming an Arduino (robot) along the way?
    (There! Arduino is mentioned, the comments can commence to collapse) B^)

    I used turtlegraphics years ago to begin learning Java, much like LOGO, but now none of my programs work…

    1. Arduino support is among the thing we’d love to have in the project. There are some though about how to do it but nothing beyond. We’d happy to work together with people that offer to help. There irc channel is a great place to say hi and chat about first steps.

  2. I recently bought an EV3 for my kids. I was less than thrilled by the whole graphical programming thing. While it’s easy to make the motors spin, I found it much more difficult to change behaviors based on sensor input, e.g. go until color sensor senses red then stop. I finally settled on ev3dev which has python bindings. Best thing is that you don’t have to flash the firmware onto the EV3 brick– you flash an SD card, insert it into the brick and it boots into a linux environment. I find it much easier to do things– built a marble color sorter over the weekend with the kids.

    1. Neat! The graphical programming interfaces seem to forget that plenty of text editors exist that don’t have the problems described in the blog (mismatched parentheses or quotation marks) and actually automatically handle them in an intuitive manner. Using scratch, for instance, seems like writing an essay by copying and pasting slips of paper from a dictionary. Words and letters are much more convenient than blocks most of the time.

      1. I’m a words guy myself, but this isn’t aimed at people who’ve been coding for 20 years. I think the put-it-together style has been shown to be more intuitive for younger folks.

        Imagine how stoked they’ll be when they figure out that they can just type “if” and hit tab!

  3. Heads up editors: the cartoon robot graphic has a transparent background, and the shape outlines are in black. It looks fine on the gray background on the article page, but the neck and eyebrows disappear completely against the black background of “hackaday.com/blog”.

    Regarding Open Roberta… this sounds very familiar… specifically the name. I think I remember my cousin mentioning that she used this in high school several years ago, but I forgot to look into it. Does anyone know how far back it goes?

    1. Hate to double post, but I just found a sufficient answer:

      ‘With help from the EU financed “Roberta Goes EU” project, the Roberta concept has been successfully extended to further EU countries since 2005.’
      –http://roberta-home.de/en/roberta-network

      so the “Roberta” name as applied to robotics in education predates 2005, and my cousin was in high school from 2006 to 2010. It’s feasible that she could have encountered it, so I’ll have to contact her and find out now.

  4. The Roberta initiative was startet in 2002 in Germany. This initiative was called “Roberta – Grils conquer Robots” and was funded by the German Ministry for Education and Research (BMBF). In 2005 Roberta became a EU funded project “Roberta goes Europe”. http://www.iais.fraunhofer.de/uploads/media/RobertaEU-Final_Report_01.pdf

    Open Roberta is a project which has been initiated together with Google.org and Google Germany.

    Tons of information are here:
    https://en.wikipedia.org/wiki/Open_Roberta
    https://mp-devel.iais.fraunhofer.de/wiki/display/ORInfo/Open+Roberta+Wiki
    https://dev.open-roberta.org/willkommen/

    For more questions write a e-mail to the Roberta headquarters roberta-zentrale@iais.fraunhofer.de

    Best regards,
    Thorsten

  5. Nice! After reading this, I immediately started experimenting with ev3dev+OR on an EV3. I would hope that ev3dev would become popular as a platform for open-roberta, but currently the ev3dev/OR combination is a little underdocumented.

    Installation is not so complex though, just download the vanilla ev3dev image. and enable openrobertalab service as described here: https://github.com/OpenRoberta/robertalab-ev3dev
    Enabling is done by running the following on the brick in a terminal window.

    sudo systemctl unmask openrobertalab.service
    sudo systemctl start openrobertalab.service

    Then there is a small problem that the OR application expects a v1.4.0 “firmware” (=OR service on the device), while the image I used declared itself a version 1.3.2

    This can be fixed using the comments in this ticket:
    https://github.com/OpenRoberta/robertalab-ev3dev/issues/19
    Which means running the following on the brick:
    sudo apt-get update
    sudo apt-get install –only-upgrade openrobertalab

    Those lines upgrade the openroberta version on the brick to 1.4.0

    Also useful to note is that although ev3dev is a native/binary environment, the OR service appears to be 100% python, which means that you don’t need to set up a cross-compilation chain to hack/fix any issues encountered with OR on ev3dev. You can simply ssh into the brick and fix the scripts on-site if you want.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s