Very good question ;-) Just some thoughts:

I think it strongly depends on things you would like to teach or learn. From my point of view Arduino is a very good starting point if you would like to interact quickly with the physical environment using servos, electrical motors and so on. A lot of books and examples exist and a very simple IDE is also provided. We successfully used the arduino boards for controlling, e.g., smaller doors that can be opened and closed remotely in the context of a robot laboratory. The students, realizing this functionalities, have been able to work with the arduino boards with nearly no introduction into technical details of the arduino solution and also accessing sensors and actuators is well supported by the different types of AD/DA converters. Nevertheless, more complex functionality (like complex control-functionality of a mobile robot, including navigation, obstacle avoidance, path-planning and so on) can rarely be realized using the Arduino boards due to the limited resources.

We tried the same with the raspberry PI, which provides much more resources, but the students in our case have not been able to straight forward access actuators like in the case of servos. Further, if using the standard linux kernel, provided for the Raspberry PI, the timing behavior was sometimes confusing for the students. Realizing control-functionality being executed with a clearly specified frequency becomes complicated because of the missing (hard) real-time support.

In the context of our lectures we use a solution containing a PC104 board running a patched linux kernel (patched with RTAI) providing real-time support. Sensors and actuators are accessed by a second board, that is communicating via a serial bus with the PC104. On the one hand this solution has the drawback that it is much more complicated compared to the Arduino boards and requires some time to gain inside (teaching/learning in DIY is rarely possible). On the other hand we have created and overall tool-chain taken from the automotive domain (AUTOSAR conform), allowing to realize real-time capable complex application examples for the control of a mobile robot. This tool-chain allows students to get hands on topics like model-driven development, the usage of code-generation techniques, programming of different types of real-time systems (hard and soft real-time) and so on. So students can gain inside into topics that can rarely be treated using arduino (e.g., defining different types of real-time behavior at the OS level).

So from my point of view Arduino is a good starting point but it highly depends on things you would like to teach/learn …

Maybe that helps?

I have used Arduino in a Software Design for Engineers course for many years and it works really well and the students are able to put together reasonably complex projects involving Zigbee wireless networks, actuators and various types of sensors. I would be hesitant in using Arduino in an embedded systems course because the kernel is very primitive and lacks many of the services students need to learn while playing around with real-time kernels.

I'd definitely second Stefan's and Imran's arguments and suggest starting with the Arduino in physical computing. Low clock speed and small RAM will urge the students to concentrate on fundamental tasks. The operation voltage of 5V is a great advantage, since all TTL ICs will work without additional level shifters. Moreover, there's a plethora of shields and corresponding libraries available for the Arduino.

However, don't neglect the Raspberry Pi, being a full-fledged Linux platform which can communicate with the Arduino. Eventually, you might teach how to gather data using the Arduino and process them on a Raspberry ;)

Great ideas and comments...

Maybe Arduino is more suitable for a introduction to programming, or introduction to computer science, and Raspberry Pi is better for Operating Systems or Sensors Networks. The idea of having the Raspberry collecting data from Arduino is not bad at all! I will try it :) Thanx

You can combine RPi and Arduino by getting the Gert Board with the RPi. The advantage here is you get the best of both worlds and the RPi can run the development system for the Gert Arduino section.

We have some development boards from Mikroelektronika Company, particularly BigAVR boards and dSPicPRO3 boards at our Institute. The teaching of microcontroller programing with the use of BigAVR and AtmelStudio6 (avrgcc c compiler) is a very good choice. The big community of people which are able and willing to help with problems in http://www.avrfreaks.net/ forum exist.

The RPi ($35) with the Gertboard ($46.80 assembled will give one 12x buffered I/O, 6x open collector driver, Motor Controller, ADCs and DACs plus a Atmel megaAVR for Arduino) has loads of open source software available. The Gertboard even has a small prototyping area. In addition there are a ton of YouTube videos for the RPI, many of which are very helpful to the novice. Four months ago more than one million RPis were sold. it is probably double that now. The RPi community is large, helpful and growing very fast.

As a beginner in hardware start with the Arduino. It is very easy and there exist tons of tutorials and help online. I see the Raspberry more like a mini server to play around with linux for example to use as home webserver, fileserver or mediabox. You can also combine both.

If you want more power on the Arduino get the Arduino DUE.

If you want something really cool that's basically a mix of both but more powerful check out this kickstarter project: http://www.kickstarter.com/projects/435742530/udoo-android-linux-arduino-in-a-tiny-single-board?ref=category

But really to start easy and cheap get the normal Arduino, buy some sensors and actors with it and this will keep you busy for a couple of weeks. Have fun!

Rubin, I'm not sure putting the RPi and the arduino on the same board buys you much since one of the ideas of arduino is to embed it into something else minus the development system. Many will want to use the linux system as a regular PC for games, open office and software development. Others will leave the boards plugged together to program a board then plug in another board to program it with a slightly different program, etc. I guess I'm for maximum flexibility at the least cost, especially for teaching kids or novices.

The PI is more OS oriented, Arduino is embedded systems oriented and gives your students a better understanding of how the MCU and its software interact since all the abstractions of an ordinary OS aren't there

For a beginner, when what you want to teach is embedded systems the arduino is the answer, when you want to teach programming the scratch application on the Rasperry Pi is better, but you have to deal with much more overhead in the RPi so getting little toy applications up and running quickly is easier with the Arduino. Locally we have begun to see a new circuit called the PCDuino that is essentially a combination of the Rasperry Pi circuit and the Arduino circuit.

The main difference is the sophistication of the ARM chip, which is full 32 bit technology, and thus needs a full blown operating system to run, while the Arduino uses 8 bit RISC technology which doesn't have room for a full blown OS, and makes you more aware of the hardware as a result. I think the choice of the two depends on whether you are teaching software or hardware, for software start with the RPi for Hardware start with the Arduino.

Hardware and software are really two sides of the same coin. I generally teach them together.

Gary, you are right. But I still think it's great idea putting everything together and making it a bit more powerful. This way will make it easier to develop more complex systems still using relatively low cost hardware. :)

It has been said that Hardware is just fossilized software

But a full fledged operating system is considerably more than a simple setup and loop system as found in arduino. It might make sense to work up to it. Arduino is just so much more basic that it makes a better starting place.

When I was taking the microcomputer course, we started out with a basic monitor and then worked up to a BIOS.

IMHO the best system for that purpose is the Arduino, as it is simpler (HW & SW-wise) and help students understand the basic concepts of both HW and SW: ADCs, DCAs, I/Os, ALUs, PWM, types of RAM and ROM, architectures, processor speeds, assembly and C language, etc.

Then you can introduce them to the RPI which will definitely take them to the next step in every sense and allow them to build more complex projects, as the platform itself is more robust.

I agree with the comment by Graeme on the HW being fossilized SW, so the more complex the platform is in terms of HW, the less effort you need on the SW side to perform the same tasks. This may allow you students appreciate the HW complexity in terms of the benefits this brings to the SW development, at the same time that it permits creating more complex software to reach higher goals.

Then you can move to the BeagleBone Black! ;)

Raspberry Pi

What many seem to be missing here is you need another computer to run the software that allows you to program the arduino computer. Here you might as well use the Raspberry Pi since it is only $35. Now you have two tools to teach computing. They can be integrated together as Ruben suggested or as two separate boards that plug together (RPi and GERT) that provide a bit more flexibility at the cost of some elegance.

We can use Raspberry PI to develop Arduino, and both are complement.

44 (0)1223 221 202

Hi Vsevolod,

Should we call you? :)

Following answer discussed lots of general thing but not given exact the requester want.

As a student ,I 'd like my teacher tell me what can Raspberry Pi and Arduino do. And if I finish the relative project, what can I learn form them. So after that, I will choose it.

Bharati, I think it is not possible to give the one right answer. It depends on what the goals of the individual users are. People here tried to outline that each device is a little bit different. Everyone must decide for himself what he needs and what is best for him. You can use the answers here to get a better picture and make this the ground for further research or even the decision.

Raspberry pi is basically a computer. Arduino is more like microcontroller with interface hardware for you to experiment with. Arduino is more robust to handle abuse such as a wiring mistake one can make in a project. Raspberry Pi, on other hand, expect you to provide voltages that it is designed for. It can also be damaged by electrostatic if not handled properly. Like Gary Felerbach said, arduino needs another pc to let you program arduino. Raspberry Pi is a complete pc that can be interfaced with outside world (if you know what you are doing). Also it can be easily converted into a mini-server. If you are first timer, go for arduino, then for raspberry pi once you get experience.

Unlike general purpose processor systems (PC), the embedded systems are dedicated to fulfill a special function within a larger mechanical or electric systems. thus, the first step is to chose the technology for implementing the embedded system (FPGA, DSP) which cope with the application requirements. From here on, in case u are choosing FPGA for implementation I can give u further advice. You will need knowledge in implementing digital logic using VHDL language. Also, C programming is necessary for developing the software for the embedded system. To conclude, these are the basic steps for developing embedded systems. A more detailed description of implementing application specific hardware architectures within an embedded FPGA based system for image processing can be found in: "FPGA based system for automatic cDNA microarray image processing", Computerized Medical Imaging and Graphics, Bogdan Belean, Monica Borda, Bertrand Le Gal, Romulus Terebes which is posted on ResearchGate.

Hello Alisson,

Assuming that you are intending to write a course for teaching undergraduates some "principles of systems engineering" or similar I would say that the Pi is a bit too computer oriented. Interfacing custom hardware is not impossible but it would detract somewhat from the core teaching which should ideally be platform independent. The Arduino on the other hand is a bit too easy to use. Some of the important things like status bits and ISR routines are hidden or partially hidden from the user in order to speed up development. This is of course an advantage if you are already proficient in embedded system design, but if you're learning then these things should be exposed. Have you considered some of the more powerful AVR chips? You might also approach Freescale Semiconductor, or Microchip, ARM is not out of the question either. If you are planning to buy in 100 or so demo boards to kit out a teaching lab many of the big semiconductor companies will give very favorable rates, especially if you are representing an academic institution and using the hardware for teaching purposes.

If you're teaching undergrads it doesn't really matter what platform you choose because when they hit industry they'll have to get used to whatever platform their company prefers. It's best to try to make sure they understand the basics that support all embedded systems. To do this you'll need to find a platform that isn't so powerful/complex that they can never get on with it but not so easy to use that their potential for learning is limited.

Best,

James

Has any of you consider STM32 Discovery kits? In my opinion, Raspbery is OS oriented while Arduino (with AVR) is still 8-bit architecture. STM32 (Cortex) is a modern 32-bit architecture and kits are very cheap.

Hi, I'm the chief electronic engineer at Caltech's Space Radiation Laboratory. Here we build small scientific instruments that always include an embedded processor. We have always used FORTH as the programming language and since the early 2000's have been using a simple processor that can be embedded in an FPGA as a soft core. I recommend teaching using one of the many prototyping boards available for the various popular commercial FPGAs from say Altera or Xilinx. That way the students can learn both hardware, by designing a simple processor and implementing it in an FPGA, and software, by writing a simple assembly language cross-compiler for the said processor and using it to write a simple FORTH system and getting it to run. This "birthing" of a new processor system is a powerful confidence booster for anyone who tackles and masters it. For help with this the best person to contact is Dr. C. H. Ting. Just google him and hopefully he hasn't retired. He can provide documentation for both simple public domain processors and FORTH systems for them if you choose to go that way. (Dr. Ting helped us define the simple processor we've been using and provided a basic FORTH system for it back in the early 2000's.)

Go for Arduino. It would be lot more easier to have some hands-on and understand the Controller's functionality. You need to know only C/C++ to code using Arduino IDE instead Android or UNIX (Raspberry PI). For initial understandings and basic concepts Arduino is a good choice.

We started using STM32F100C4T6BTR in some products in the last 2 years.

Part is very flexible, and development kits are quite inexpensive.

I would recomend the STM32Fxxx Discovery boards, especially take a look at the F3 series. Cheap, powerful, and has analogue signal conditioning integrated into the main chip. Plus, it is a real development platform. Arduino and Raspberry are for hobbysts, many important details are hidden or even unavailable due to restrictive SDKs. They are not an education platform, unless you are trying to do projects with children, artists, lawyers or other people generally not interested in using these tools proffesionally.

I think the issue here is whether or not the platform is suitable for beginners. Arduino cossetts the programmer by making a library available that smooths out the programming gotchas, and that might work against long term viability, but it gives you a quick simple interface to get up and running with. It might take longer to get into the Raspberry PI and other cortex chips, and it might be especially more difficult to program a base controller into an FPGA, but these are later steps in the process as well, as someone who has worked with Forth, I have to say if you have seen one forth you have seen only one forth, they are individual to the programmer, and teamwork is much more difficult as a result.

I am only a student but i would like to offer my opinion if it is worthy. I have learnt to program embedded system since high school purely out of interest. I started on a simple 8-bit harvard architecture PIC micro pushed into a bread board with nothing but the internet as a resource. The PIC was a brilliant starting place for C as Microchip offer a free IDE aswell as compiler and libraries. Although the assembly was a bit trickerier than say with the HC11 that i used at university for my first assembly class it was well worth the time. It is only an 8-bit micro but offers enough RAM and FLASH to built quite large projects well and truely large enough for undergraduate ptojects but still limits the designer so that they cannot just use a double where ever it suits them. This is my experience from a learning point of view. FYI i use ARM M3's now for the performance gains

PS i personally own a raspberry pi and ardunio platform and would have to say that the raspberry pi would be extremely intimidating to someone new to embedded design, also i strongly agree with the comment made about the hardware design side of thing i feel it gets heavily neglected at the undergraduate level as evidenced by most of my friends not being able to even get a simple AVR or PIC working on anything other than a dev board which would be a rude shock when they enter industry

I'd like to propose the Open Source Linux ToolChain for STM32 CortexM3 Microcontrollers: http://thetoolchain.com/readme.ToolChain

The basic idea of this tool chain is to provide a free to use and free to modify solution for software development in embedded systems. As a logical consequence of this idea, The ToolChain should run on most Linux based operating systems. It is not intended to run on closed source proprietary operating systems. It is a compilation of install scripts and software libraries beeing written by Gregor Rebel and several students of the University of Applied Sciences Muenster between 2010-2013.

In my opinion, it is an issue of scale and resources. I teach a small-scale embedded systems course using PIC micro controllers. In this class, we have no OS and students build a library of device drivers (LCD text display, SPi EEPROM, keypad matrix scanner, etc) that they use to produce a final integrated embedded application. All coding is in C with some analysis at the asm level. My goal is to have students become familiar with how to interface with devices, manage real-time constraints, handle interrupts and get practical experience with structured software design. To do the low level tasks, it is helpful to have total control of the CPU (unencumbered by an operating system) and Arduino may be a better fit. However, another concern for teaching a course is the lack of a suitable textbook and I'm not sure there is one for Arduino.

If your goal is to do something on a larger scale without real-time constraints perhaps RPI is more suitable. However, writing a device driver from scratch for Linux is not for the inexperienced and I would be concerned about the lack of a textbook if you are teaching to undergraduates.

Good Luck.

I appreciate Prof.Kevin Austin's approach of making the students learn interfacing,from scratch for themselves. This was the approach followed at I.ISc., Banalgaluru when I did Courses on"Micro Processors' and 'Design of Microcomputers',long back during the middle of 1980s. We were made to Design S/W for Key board interface,Monitor(CRT Display chip) display etc and test for ourselves.At that time we were programming in Pascal as C was not in Scene then.

P.S.

I have and use a Raspberry Pi and three Arduino systems, +30 yrs experience developing embedded systems. The best solution for teaching embedded systems development will depend on your students. If they are familiar with Linux and perhaps Python, then the Raspberry Pi could be used for some digital I/O apps (The RPi has audio output but no analog input).

If your students are not experienced Linux users, go with the Arduino boards. There isn't a much easier way to get into embedded systems. Many "learning kits" are available that help give students a hands on approach to blinking LEDs, measuring analog signals, running servo motors, and more.

The Arduino libraries make it very easy to start with a working demo and modify the code for your particular application. The optional Ethernet Shield makes it very easy to make a SD card data logger, or a web enabled sensor port.

I have a very simple Arduino app that measures some data and "pushes" it up to the "cloud". See: http://www.mygridtracker.com/

Have fun!

An interesting article about this topic just appeared in Electronic Design Magazine :

Arduino, Raspberry Pi or BeagleBone?

Jun. 3, 2013, by William Wong

http://electronicdesign.com/modules/arduino-raspberry-pi-or-beaglebone

I taught 《embeded system hw and sw design》 last spring，i want to use Panda board，it is cutting-edge design with especially multi-core SOC。 but my students thought it was too expensive。 i had to changed to “SMDK2410”， which is out-of-date arm9. But it is OK。

I thought stm32 is not enough， cause it is a mcu。all things are inside the chip，students would not get the idea of SDRAM，buses，bootloader，Linux。

I think use Arduino than PI, because of Arduino has more lib and can applied for computation algorithm

Actually the low level details are glossed over by the language

The question is, is it important to have all the details, or is it more important to have a successful lab early-on. I think it depends on whether you want people to compete for marks, or to be successful and build expertise. Once the students have been successful, they can be introduced to the more difficult microprocessors like the PIC.

As long as they are exposed to the low level peripherals they are going to have experience with them, but they will not be as frustrated if you start them off with an easier problem.

At the AGH University we are teaching Emdedded Systems on ARM microcontrolers: simple STM with FreeRTOS or MIcrium uC/OS and more complex ARM with MMU (Cortex A8 or A9) - this year it will be probably BeagleBorad or PandaBorad with some embedded Linux.

Of course "Embedded Systems" is wider concept then just microcontrollers with OS, but more important is teaching right metodology of designing fully operational embedded system from requirement analysis, work planing and constructing prototype in any technology.

I think it has to be answered in context of the purpose of the learning/teaching. If this is a group of students who you want to introduce to thw world of embedded microcontrollers with the thought that they may someday build their own circuits, the I think the PIC microcontrollers from Microchip are the way to go. I would set them up with one of the explorer boards which have the interfaces/leds/switches and a bunch of sample "tutorial" programs to load up and modify. It is a small step from there to building your own.

If the idea is to give a group a very quick introduction to the potential, then the Arduino's are pretty good for getting something going quickly. However, in my opinion, there is a larger step from Arduino systemsjavascript: to building your own specialized systems with embedded processors. In that case, you can show them what is possible, and you can even build systems with a full Arduino and appropriate shields incorporated, but that is not very satisfactory for a fully embedded system design.

The Raspberry PI is great, but is probably still finding its niche. As previously pointed out, you need to deal with the operating system layer, which is an unneccesary complication in the classroom environment--especially if the goal is to move from there to independent embedded design.

For "true" real time application, Arduino is what you should use.

Otherwise Raspberry is excellent for learning how HW meets with SW in the embedded world.

If you have a medium sized problem of the order 64K code + 64K data, the ARM MBD might be the answer. It comes with a web based compiler and various C++ libraries to support the peripherals such as displays, temperature sensors, accelerometers. As such the code that runs is quite fast allowing for interrupts and other goodies out of the box.

...now you can have "both" (I mean cheap ARM with 4 cores and Arduino).

Do you know UDOO ?

Look here http://www.udoo.org/ I have one :-)

Although the question is not newly posted, I will answer at least for those who will read this eventually:

Taking into account my experience I would suggest:

1. One should start with low level microcontroller manipulation using assembler programming language.

- For example Avr are very good (also Microchip) ARM based architecture

- Assembler language gives also hardware insight and efficiency in code

- Simulator using Isis Proteus(can simulate assembler code directly in an electronic circuits or even motors simulation)

- At least a few physical implementations using specialized programmer on a breadboard

2. Afterwards Ardruino with high level languages or even Simulink modules for faster solutions.

3. Finally I would suggest aside the "Raspberry Pi" solution, FPGA programming and implementation("Veriwell Verilog software" is very simple for learning Verilog lnguage) FPGA boards for educational and simple projects exist on the market.

Neither! Take a look at the Beagle Bone Black (and xM for digital media). They are high performance, the Black is the same cost (if you include micro SD card and power) and faster, has more open design, and just all around easier to teach with in my experience. Great tools for OS-less, lots of Linux options, and about the only thing missing is a good FreeRTOS configuration. In my experience Arduino over abstracts, but good for hobby projects or for a very first course on embedded and the Raspberry Pi has proprietary features that lead to frustration for serious DSP work.

Based on my experience Raspberry Pi more features

Very interesting question. Most answers relate to technical features and its applications of raspberry pi and arduino. I am not a student but I remember what was like to be a student. From student point of view, I would like to do projects that are affordable, that is diverse in applications and practicality. I would choose raspberry pi because the kit is most economical. I can use different operating systems, and it has well documented support and library of codes to play with. If by accident I bust the board, it will not cost me much to replace it and that is important. As a teacher (who I am not) , I should always keep it my mind that all students are rookies who excel at one thing, busting their projects which is perfectly normal and part of learning process.

Saying that the beagle bone black is the same cost as the pi, once you take into account the SD card etc, is the same as saying that the beaglebone black is not the same price as the pi, because it comes with more equipment. If what you want is a bare bones project, then the PI is cheaper because it was designed to be saleable in a more bare-bones format for purposes of expense. The proprietary nature of the software/hardware is a concern since anything that can't be explained because it is unknown can't be taught. if the cost of power and SD cards is the breaker of your budget then by all means get the pi, but if you can afford the difference, having better documented hardware/software is a distinct plus.

There are hibrids that combine PI clones with Arduino components which gives you the best of both worlds.

The context of the teaching is what will really determine the best. Is it part of a curriculum where the students have good software skills? Is it part of an Electrical Engineering Program where they understand digital interfacing?

Both have great support, and can serve as stepping stones up or down the technology stack, but from different directions. The key thing I find is if the student can purchase their own systems (they are cheaper than texts) they can greatly improve their familiarity beyond the lab time available.

I guess the answer depends on the teaching context. Personnaly I teach computer science to students in a professional enterprise-applied BA. We have chosen the Raspberry Pi (notably the Keno starting kit) as they have a nice design that positively impact the students. Also I think the range of applications is more wide for Raspberry Pi. I am planning to teach students how to create a video monitoring system, along with how to use XMBC in order to transform an old TV into a network media jukebox. If the students have solid skills on such platform, they can easily adapt when using Arduino in combination with Pis. But this goes for computer science students. If you consider other teachning domains, maybe Arduino is better for a start...

I designed and initiated the embedded course and lab in the Computer Engineering Department at the University of Jordan. Utilizing many years of work with embedded systems in the industrial sector, and for a first course introducing basic embedded systems principles and microcontrollers for engineering students of Electrical, Mechatronic and Computer Engineering students, the emphasis was on gaining in-depth knowledge of the inner workings, build appreciation for the flexibility and diversity of the different abilities of peripherals and components. For engineers, I find that it is essential that they work in the beginning at the lowest level possible. That is why we used PIC microcontrollers and the assembly language. Later, we move to C language and compilers. In the end, a substantial project is required. The experience is told in detail in a couple of papers that I have published. For more info, please check my profile.

Raspberry is not a microcontroller system, it uses an operating system and the only inputs/outputs are the GPIO. If you want a system that could offer analog and digital inputs/outputs, PWM … you should select a microcontroller system. In my department we use TI tiva systems. The university program of TI is very interesting, and the tiva system with a cortex M-4 microcontroller is really cheap. Also it is possible to obtain a university agreement with ARM, in this case ARM will offer ARM cortex-M and they development tools free of charge.

I hope, you got satisfactory answers. Here I just want to include that if you know 8051 microcontroller then as per your application you have to select otherwise if you want to learn then my suggestion will be start with 8051.

I think that there have been enough answers already to sample them and give a summary, it depends on your subject matter, and how familiar the students are with the project boards which is better, and in many cases there may be other options that are more economical but involve agreements with the manufacturers etc.

If what you are looking at is an ARM device, then there are many alternatives including beagle board, ti tivo, etc. that may be competitive in price and more accessible than the raspberry pi. but these tend to be slightly more expensive and not come with the raspberry pi software. If you are looking for a data aquisition product then the simplicity of arduino comes into play, but it is not the only risc microcontroller out there, consider the pic series which have a more expensive C compiler but can be programmed in each chips unique assembly language. Or consider the 8051 which is venerable cisc architecture and much easier to explain than risc architectures.

The Course determines which board to study, or whether or not you need to study a board at all, a course in design for instance might want to start with the chip and produce it's own board. Certainly choosing a chip, is a learning stage that can't be discounted since there is so much variation in design. One reason why PICS are so popular is that they have a wide range of chips to choose from, and the individual architectures while unique to each chip, are close enough in design to allow cross training on assembly language. The arduino is a popular choice because it is cheap and readily available. So is raspberry pi, but is this really the best reason to choose a platform? consensus is, probably not.

Hi,

Raspberry PI is a special kind of a embedded system called "embedded PC". You feel like working with an PC but the Raspberry PI allows to integrate very easy (by Port) sensors or actors like an microcontroller. The Processor is an ARM Cortex M Series derivate, 32 Bit technology with OS.

Arduino is a microcontroller system based on ATMEL processors together with a special kind of script language witch allow to build very easy applications also without so much experiance in embedded systems.

You can not compare both seriously. Both are not the best way for understanding the principles of embedded systems.

Having tried both and having a bit of experience with microcontrollers in general (mostly microchip's and ST). I would say that the arduino is faster to get working. In a week if you already have knowledge in C programming you should have managed to cover every part of the device. Whenever I have a new sensor to test or a quick proof of concept I have to make I test it on an Arduino because of the user friendlyness. A positive point is that almost every sensor or device has already been tested on the arduino because of its popularity among hobbyists. That leads me to say that it is a bit limited in terms of functionnality and performance (mostly performance).

The raspberry Pi takes a bit longer to get used to if you don't have Linux based systems knowledge but offers wider possibilities because of the multiple programming language you can use, its better performance, its connectivity (usb ports, hdmi, etc.) and a good point is that it can run a full RTOS. I cannot express anything more concerning this device, I personnaly think running a Real time operating system is really heavy and I don't appreciate it as much as I could.

I think they both are interesting in terms of content it depends on what you are planning to do. If what you are really iterested into is learning microcontrollers, peripheral interfaces, etc. Then you should probably opt for a more crude device where you will learn to program in Assembly and TRULY understand what every cycle of your precious clock and energy is used for. Once you worked with uC in assembly, you can move to any other family because you understand the inner working of the devices (within the architecture you were using).

Also, if you are planning to publish papers concerning hardware my personnal opinion is that unless it is a really quick prototype, an Arduino based research project looks amateur.

Arduino could be more beneficial than Raspberry Pi. In case of teaching, they must have an introduction about microcontrollers and it's helpful not to tackle through it deeply.

Arduino is entire microcontroller ecosystem, whereas the Raspberry is more or less a single device.

I recommend to got with Arduino, because it offeres capabilities on all levels. If you need an embedded Linux got with Arduino Yun, which offers similar capabilities to the RPi. If that's not so important, use the Arduino Due (ARM processor). The smallest member of the family would be the Arduino Uno (AVR processor). Besides using the Arduino IDE, you could setup your on avr or arm tool chains and program the devices in C/C++, but still profit from the large number of peripherals (shields) that the platform offers.

The Arduino Uno IS an 8 bit microcontroller But it is a RISC microcontroller, and as such it's assembly language is difficult to learn, besides the C language comes free. C is near enough a low level language that it can do almost everything that assembly language can.

The arduino uno is very much a breakout board for the AVR chip.

Many answers are already here but as I have worked with both of them, I would like to give my own opinion.

Arduino is more like a microcontroller developer kit and Raspberry Pi is a mini credit size PC.Arduino is the easiest way to learn and teach embedded systems.So for students interested in developing a Robot or some other automation kind of thing Arduino is the best choice.Arduino requires basic programming knoweldge.

Raspberry Pi with higher processing power is more suitable for works that we commonly use our PCs for.For projects like a media centre,a karaoke machine, a home server you can use Raspberry Pi with ease.  So basically wherever you think you need a little PC for any task Raspberry Pi comes into picture.Raspberry Pi was created to teach programming language to children of all ages.Rasperry Pi community is also being developed in a such a manner that a person with no programming knoweldge can use it for its purpose following simple steps.For e.g. consider XBMC(RaspBMC) for RaspberryPi, just boot a 'noobs' installed SD card select RaspBMC and you you are ready to go.

There are many other open source choices TI's Beaglebone Black, Intel Galileo(another Arduino with Intel chip on it) , Teensy and many more.So its a matter of choice, requirement and availability.But for me Arduino is winner for getting started with embedded systems.

 The traditional micontrollers like PIC, 8051 are necessary to learn the basics of embedded system but Arduino and similar DIY kits provides a easy way to get started for anyone with interest in these things.

Learning objectives of the course will point to either. Hands on approach  with the support of good IDE such as the Studio6 makes learning with understanding of arduino better.

I have worked recently with other alternative that is something between the raspberry PI and Arduino, Intel Edison/Galileo, this platform is a Linux embedded system with Arduino Emulation, you can program this platform like a Raspberry PI or like Arduino or like a mixture of both.

Hi all,

I think it depends on the goals behind the courses you planned. Embedded systems courses, in my opinion, varies from simple assembly instructions and µP basics, to complicated systems with eventually Embedded OSs, RT apps, and so on. I also think  it depends on the students backgrounds. I agree with Mark and his approach. Working with arduino is more handful and you can develop a full course from scratch to a complete design of a functional, realistic case of an embedded system like robotics control, Signal precessing, Networking app (generic or industrial), just be sure to provide the right shield to the right app. In the other hand, if you plan to push further the course content, with and embedded OS, like embedded Linux for example, Raspberry Pi will be more suitable, in my opinion. Other options are also available like the beaglebone black, intel galileo as Alfonson says, and even arduino yun, take a tour here for a cpmarative study between cards

https://learn.adafruit.com/embedded-linux-board-comparison/overview

It depends on the goals behind the courses we planned.

The choice depends on what you want to do. The Raspberry allows more computing power than the Arduino but is more expensive while the Arduino provides better possibilities for I/O.

Recently, was released the promising Raspberry Pi Zero ($5 price)  which is a basic RPI with great potential in embedded systems.

After working on both Arduino and Raspberry Pi, I would like to give my opinion in the context of the question asked.

Arduino is a great platform for beginners. It is low-cost, easily available and easy to get started with. However, it is a microcontroller, not a microprocessor. Hence, there are limitations associated with Arduino.

Raspberry Pi, on the other hand, has all the functionality of an Arduino (because of Pi's GPIOs) and has more advanced computational functionalities than Arduino. Hence, in my opinion, the best way to get started with embedded systems is by using Raspberry Pi. As you advance to more computations using multiple peripherals, Arduino might not serve the purpose. Moreover, Raspberry Pi supports an interactive GUI which helps people of all the ages to be familiar with the functionalities of Raspberry Pi.

An Arduino is a microcontroller motherboard. A microcontroller is a simple computer that can run one program at a time, over and over again. It is very easy to use.

A Raspberry Pi is a general-purpose computer, usually with a Linux operating system, and the ability to run multiple programs. It is more complicated to use than an Arduino.

I think there is no general answers for your question. It depends on your goals.

If you want to teach how a microcontroller works, and how to interact with basic peripherals, you should use Arduino.

If you want more high level applications: networking, web interfaces, linux services, programming in Python!, etc, is better to use Raspberry Pi.

In my Introduction to Electronics Course for Pregraduate students I use Arduino, and combine the Arduino API with configuration of internal registers of the ATMega microcontroller. However in most of my research I use Raspberry Pi and sometimes both.

For Computer Engineering or Electrical Engineering studies, the best would be learning the C programming language and using it to program AVR, MSP and PIC microcontrollers.

Both Raspberry Pi and Arduino will not teach you the in and out (A & O) of Embedded Systems