If model based feedback control for MIMO plants is what you do, with sampling times in the order of, say, 20ms or smaller, you will run into problems related to real-time requirements (Can you prescribe the time at which a measurement is to be taken? If not, can you determine that time afterwards, and can you guarantee that the measurements of two different states of a single process are taken at the same time? If not, how would you design an observer?). If your plant is very simple, you probably can circumvent these problems using a single Arduino. If your tasks are more complex (fast dynamics, need for observers, communication, low-level and high-level tasks), you will need to use either several Arduinos, or a Raspberry or so. You could also specialized but still inexpensive hardware for the measurement tasks. In either case, the timing issues are a problem. We are currently investigating several variants of relaxing them. Once we come to a solution, I will post it there:

https://www.researchgate.net/post/Real-Time_Linux_on_Phidgets

Thank you for the replies Ilhan and Gunther. The timing issues you both raised are excellent to know.

At the moment, flexibility is more important to me than performance, which why I'm looking at more general purpose processors. The intent is use them for quick prototyping to demonstrate a specific research concept. So speed from a development standpoint is more important to me than speed from an execution standpoint at this time. Of course, I need to ensure that the microcontroller I use meets minimum threshold performance requirements for a demo.

Are there any comments on ease-of-use, reliability, flexibility, etc for any of these microcontrollers? I will have a learning curve for whatever one I choose at the beginning, but I would prefer to go into it well informed. Thanks in advance!

* Arduino seems to be extremely simple. I bought two "Arduino Starter Kits" and let two students (one first year, one third year) experiment with it over Christmas. The money was well spent. Both students came back to tell me that everything is foolproof and any interested highschool student should be able to work himself through the experiments in the book without assistance. (I have yet to test that kit myself once I have a free minute...)

* Phidgets SBC 3, RaspberryPi: A PhD student of mine is using both, in connection with phidgets IO-cards. Should be simple for anybody familiar with both C and Linux.

* One more point: You said your prefer quick prototyping from execution speed. The latter contributes, however, to a fast prototyping process as it eases timing problems. My suggestion: If your project is extremely simple, use Arduino. If it is just simple, use RaspberryPi plus Phidgets IO-cards for measurements and actuation.

As mentioned above Arduino seems the most effective for fast development but for relatively low computational / timing needs.

IF you can tolerate a steeper learning curve you can have a look at Cortex-M4 with FPU. ST offers quite cheap "discovery boards" ~20$ and a nice open library to access its hardware.

Just a hint of their performance. For STM32F4@168MHz, you can get floating point FFT , then conjugate multiplication, then IFFT (all of them with 2048pnts) at ~3ms using ARM's CMSIS core..

At last a typical PCB complexity is almost the same with an AVR/PIC class uC

Yhank you, Yannis, I did not know about the 168 MHz version.

Recently I asked my students to develop basic robotic applications using either Arduino or PIC microcontrollers, as a homework. I also used Arduino for personal projects and I'm quite satisfied for the same reason that made Arduino a favorite choice for my students: the learning curve is not steep and wiring is reduced to the minimum. Also, the user base is very large and this is important (examples, forums, etc.). For the same price range, the PIC family of microcontrollers (as well as entry level ARMs) can do more sophisticated things like encoder A/B hw counters, but the learning curve is less friendly. However, Arduino has the limitations pointed out in this forum, in detail I stress the fact that you cannot implement complex programs because of limitations in memory and computational power; for example if your robotic applications require some type of artificial vision, or intensive floating point computations, Arduino cannot fit your needs.

Solutions like the BeagleBone and similar embedded-linux SOBs are more powerful and offer a true operating system (ex. TCP/IP, storage, etc.), so you can turn them in both a controller and a HMI interface or a SCADA, ex. by embedding a webserver, but remember that in most cases they cannot be used as a real-time controller unless you install a true hard-REAL-TIME OS, like RTAI linux, etc. (this to be 100% sure that your control frame is executed with a deterministic periodicity, something that happens naturally on Arduino...)

By the way, for a mobile robot with artificial vision, I am also testing some SOBs of the OMAP family (OMAP5, OMAP4) like the PandaBoard; they are similar to the BeagleBone but more powerful and expensive (they have also HDMI output) but looks like that the user base is smaller.

Just my thoughts.

Alessandro, thank you for your comments.

I would appreciate if you could share with us some of your experience in using single board computers under real time operating systems for (closed-loop) control tasks. Thank you.

In any case I recommend you to take a look at Biicode http://web.biicode.com

The are on beta yet but could make your life much easier.

Sorry for short answer, wrong button. Biicode is a tool to help you to manage source code dependencies and cross compilation support.they are working hard in Arduino and Raspberry.

Having tried using Arduino, Raspberry PI and the Beaglebone Black on various robotics projects, I have concluded that the Beaglebone Black is generally the best.

It is more capable of running an off the shelf version of Linux due to its larger memory, and is generally a more powerful bit of hardware.

Obviously your choice will depend on what you need your robot to be able to do and on your budget, but for anything more than the most basic of robots, the Beaglebone Black is my computer module of choice.

if you are developing your own hardware, then I can also recommend Altera's Cyclone V SoC chips, whch combine and FPGA with an ARM processor. Very useful.

I have used Arduino myself to a ClubBot (more on this in a bit). My husband is using Beaglebone Black for his larger and more complex RoboMagellan robot that does image processing. He has a Raspberry Pi as well, but I think decided the BB was a better choice for his application. We both belong to a robotics hobbyist/professional/student group in the Silicon Valley Bay Area called HomeBrew Robotics Club (hbrobotics.org) that has an active set of discussions all the time about these kinds of questions. If you posted this question there, you would receive active and detailed responses from all levels. One can be on the mailing list without being in our geographical area (members in New Zealand that visit once a year to present, for example). The monthly presentations are recorded (Google hosts the club) and can be viewed on the site as well. This is a very open and state of the art forum. Many "alumnae" of Willow Garage, folks active in robotics start-ups or big companies in the field, hobbyists, and academics like me, are in it.

Thanks so much for all of the great comments and feedback. I've learned a ton from your experiences. So from the comments so far, it appears that the Raspberry Pi *IS NOT* an ideal choice for robotics, as there are better alternatives: Arduino for simple, but constrained robots and BBB for more complex, more flexible robots.

I would interested in seeing examples of robots built for basic research purposes using Arduino/RasPi/BBB. I'm personally interested in ground robots, large and small - but aerial or underwater robots would be very interesting to see as well.

The chapter I wrote in a recent book (http://www.infoagepub.com/products/Girls-and-Women-in-STEM) is about Gender and robotics (K-12) and has some general info at beginning on various robotics education programs and research. I have some other contacts on underwater robots if you like. Send me an email.

Hi,

Currently I am using both Arduino and Raspberry Pi for my application.

For minor Robotics Applications Arduino is preferable, but major applications Raspberry Pi is recommended. In Raspberry Pi we can install Linux OS which is the biggest advantage in comparison.

We have been developing an undergraduate introductory robotics course and have tried a few different technologies. The microcontroller (Ardiuino) approach is nice for the precise control over the timing as mentioned above, but one thing we found is that to untether the robots from the PCs, we had to write a custom serial radio communication protocol using Zigbee radios and ROS running on the PC. In concept, this was a good idea, but the reliability of the radios has been somewhat disappointing. Based on this, I would say using a combination of Arduino+RaspberryPi would be good, or Arduino with a WiFI shield. The Arduino+RaspberryPi configuration would allow you to run ROS on the PC and RaspberryPI while taking advantage of a robust WiFI connection, and still using the Arduino for the precise timing (which can connect to the RaspberryPi over a serial connection using the rosserial package). This is likely the route we will take for the next time we run the class.

This answer mostly applies if you are looking to run a mobile robot. For a stationary robot, you would probably be better off using something like the Beaglebone Black, Odroid-U3, or full PC.

I will vote for Rasberry pi and Beaglebone , because you can run an entire Operating system on it. Multiple devices can be managed on RB and BB (RB: Rasberry and BB: Beaglebone) . You can always attach multiple Arduino to RB or BB using a serial port.With the appropriated drivers these Arduino will work smoothly with RB and BB.

Keep the Arduino close to controlling the motors and actuators. because of a small boot-loader a lot in real time can be achieved on arduino.

Between BB and RB i will choose BB because there are options to load android OS on BB. With android, lot can be achieved on managing devices, networking etc. If you are a hard core programmer than linux can be ur option over android. BB supports both of them.

Looking at the price tag, BB and RB both are quite equal. But Texas instrument (for BB) is a brand we can see as good quality. Also BB is build on RISC instruction. On performance and real time ground..... its always better to be under the umbrella of RISC instruction set (Which i guess in your case, sooner or later , you need real time and speed for your robot.) BB has lot of research background as well.

If you are too serious ... go for Panda Board ..... you can get dual core ARM processor. Probably in future we may get the multicore fecility in BB also.

If you are working with larger robotics platforms and require even more processing power you should also take embedded x86/x64 boards into account. Take a look on micro atx boards and INTEL's NUC platform(just the board), these boards are around four squareinch. You also have the adavantages that you do not need cross-compilation...

But this depends on the payload of your robot(s) and the sensor- and actor- interfaces you want to use

It depends on your requirements, if yo are simply navigating a robot on the data pof sensors etc, you can do it with Pic, AVR or Aurdrino. In case, where high processor is required like applications related to computer vision you should move to other options like Raspberry Pi, or Beagleboard.

You probably may select the platform depending of what you need in your robot. You have no limitations in programming, you can make an specific algorithm for each one if you can, using libraries and integrate some useful free-codes you can find in internet.

One important thing is the capacity of the platform in speed response and floating point capabilities if it is important for your projects (Machine vision, control, etc).

But in my hobbist opinion you can try all of those three and check which of them is the best one for each project...

An interesting discussion. As a IC industry employee, a robotics researcher, and a RC hobbist, I've used many of these platforms: TI's Beagle board/bone and MSP430s, Microchip's PICs, and Arduino plus other AVR chips. Each have their own niche cases as already mentioned.

I'm surprised though that no one’s yet suggested using a simple smartphone platform. They have its limits of course, you wouldn't want to use one for a mission critical project or component, but they are quite convent, affordable and prevalent. In a single housed package you've got an ARM or snapdragon processor, say over 2GB of RAM, however much expandable memory you can afford, a plethora of internal commercial grade sensors (IMU, GPS, Camera, microphone, ambient light... etc), radios (NFC, Bluetooth, WiFi, GSM... etc), plus you have simple HMI as a touchscreen view status and feedback or start and stop a processes.

If you decide to keep the Android OS on the platform instead of a different linux framework, you can still use ROS's java port for Android, and if you need external GPIO or any type of low level communication bus like I2C, SPI or TTL/RS-232, you could use a USB adaption like Arduino MEGA ADK, or just Bluetooth provided it’s not too bandwidth intensive.

A professor from my alma mater, David Fisher at Rose Hulman, teaches a course for undergraduate engineering students, both CS and non CS, on how they can use their personal phones for robotic projects:

https://docs.google.com/presentation/d/1cMY1bHTxkYlPpF4K-1XfVbxrV5TV8U05ez9tcZb3Cg8/edit#slide=id.g2e200109_1_0

https://sites.google.com/site/me435spring2013/

Another good example from CMU using Android phones for multi agent deployment, an ongoing project while I worked at RI:

Real-World Testing of a Multi-Robot Team

http://www.ri.cmu.edu/pub_files/2012/6/ARMS.pdf

Cheers,

Ruffin

https://sites.google.com/site/me435spring2013/

It really depends on the application, or rather, on the type of application.

For research and R&D applications, where time and convenience are often more valuable than money, I would recommend choosing a platform that offers the most flexibility. In other words, you should choose something that could be used for most - if not all - of your potential applications.

To me, this means one of two things:

1.

If space and power are not an issue, I would use a barebones PC. Something like this

http://www.newegg.com/Product/Product.aspx?Item=N82E16856102002

If environmental factors come into play, and you need to worry about vibration, dust and temperature, Logic Supply offers a good selection of industrial embedded PC's.

2.

If you're often faced with space and power restrictions, I would go with either AVR or microchip uC's. Personally, I prefer PIC over AVR, but this is simply a matter of preference. For all intents and purposes, they are pretty much the same thing.

- For most robotics, sensing and automation applications, I would recommend PIC24 (or 16-bit AVR equivalent). It's relatively cheap, has tons of peripherals, and is fast enough for most application.

- If PIC24 would fit most of your needs, but you occasionally need to do do a fair amount of signal processing, I would recommend dsPIC, which is, essentially a PIC24 with added DSC capabilities, and a few extra peripherals (CAN, for example).

- If you need more raw power than these can provide, go with the newer PIC32.

Arduino, in my opinion, is not for serious applications. They are easy to learn, and even easier to use, but they lack the robustness and flexibility of their PIC and AVR counterparts.

Regards,

Magnus

Hi,

I look after the ECE3091 Engineering Design project, which is about designing robots for competition, such as this one:

http://www.ecse.monash.edu.au/twiki/bin/view/ECE3091HR/WebHome

here at the Department of Electrical and Computer Systems Engineering. Until this year we have been using Arduino for general computation and sensor processing. This year we have discovered the great PSoC chip which has amazing capabilities. So, we have abandoned using Arduino and instead we will start using our own board built around PSoC chip. I think you should have a quick look:

http://www.ecse.monash.edu.au/twiki/bin/view/WSRNLab/GlomeridaBoard

It cost to us almost same as an Arduino Uno.

It has a 32-bit ARM processor and quite a large number of analog and digital blocks that can be programmed like an FPGA. So, it becomes possible to do significant number of tasks in hardware instead of software.

Arduino is a microcontroller-based board, while Raspi and Beagleboard are a Single Board Computer (SBC). If your application is time sensitive (demanding near to real-time responses) you need to use a microncontroller-based board such as Arduino (which is not that much powerful, but it's known well in the community and you can easily find library and codes for it), OpenRC, and NAVIO2. The last two boards are based on ARM-Cortex microcontrollers and more powerful than Arduino and they have firmware that compatible with ROS, and there are suitable solutions to control UAVs or AGVs.

If your application is not that much real-time demanding and it is computationally expensive, using single-board computers such as Raspi, Beagle, Nano Pi, or Jetson TX1/2; the latter one is much more expensive, but it's much more powerful and contains a powerful GPU computing resource.

If your application is computing and real-time demanding, you have two options: 1. Using a microcontorller-based board and a SBC together.

2. Using a SBC, but install a real-time OS (e.g., VxWorks, FreeRTOS, etc) on it.