Part of the reason for the large community interest in the Arduino is the physical standardization. As screwy as the physical layout is, by including a standardized expansion option, the Arduino developers allowed people to come up with their own solutions. If you want to replace the base Arduino board with another board that uses a different microcontroller, you can. IIRC, someone has already built a PIC-based board that uses the Arduino form-factor. (The PIC Ardunio board doesn't have the same form factor, but is otherwise similar.)

Another reason for the success of the Arduino is in its openness -- most of the PIC-based microcontrollers were closed; They used proprietary hardware implementations, so if you wanted to redesign the board to better fit into a specific space, you were out of luck. They used custom firmware and proprietary development tools, so that if you had bugs or wanted to expand the capabilities, you were out of luck. With the Arduino, every single piece of the puzzle is open: you can buy parts anywhere, rearrange them as you need, improve or modify the firmware AND the development tools. You can start simple with the Arduino IDE, but you can still shift to C or Assembly anytime you need it.

Personally, I like the Arduino because it gets a lot of things 'just right': It's not too expensive, it's not locked into proprietary tools, it's easy to start with, it's got a lot of capability, and it has a large user community, which continues to expand and do neat things.

Arm development is coming along - take a look at the following projects.

Maple Leaf

XDuino

Cortino

Illuminato

ARMmite PRO / ArmDuino

Does anyone even care about what you're developing on?

Yes and no. I've been developing on the AVR32 for a particular project, and the development environment (in particular the compile/program/debug cycle) is horrendous compared to, for instance, PIC32.

The customers don't care, except for cost and maintenance, and in the case of an arduino-like system the programmers wouldn't care because the arduino environment and development cycle is leaps and bounds better than the current AVR32 setup.

I just wonder because there is such a strong contingent for AVRs in the Arduino family. I understand that they are the official processor but there isn't a reason the code couldn't be ported to an ARM or a Freescale architecture other than cost, right? As long as there is onboard memory, I figured there could be easy migration into those parts.

There's no reason another processor couldn't be used, but there's a very good reason they've chosen a low end 8 bit device rather than an ARM, MIPS, PowerPC, etc device: Ease of use.

If you've looked at the setup for the even the low end arms, it's an order of magnitude more complex (memory mapping, caching, etc) than an 8 bit processor. But even more importantly - at the time there were no DIP arm processors, and these were meant to be used and buildable by artists and hackers, not necessarily electronic technicians and engineers who feel comfortable with even a 48 pin TQFP.

The reason the AVR was chosen over the PIC is that the PIC doesn't really have a widely used, open source, free C compiler, among other things (the SDCC port isn't mature).

I see a lot of ARM in industry (seems like every vendor is pushing one into their designs) and was wondering why there wasn't more uptake in the Arduino developer world. Thoughts?

Mainly it's due to ease of use - complexity, easy to solder, cost, and the fact that there's not much need for it. Developers like the idea of having a lot of power, but at the end of the day when all you need to do is move some servos and flash some lights with a low-end FFT, an 8 bit processor is just fine.

Even the low end cortex ARMS coming out in 28 pin packages are still SOIC, not DIP.

So the AVR had all the right features:

• Easy to solder
• Easy to get via mail order all over the world
• Free GCC C compiler
• Easy to understand the processor and peripheral setup and usage
• Cheap
• Ubiquitous - lots of people and experience surrounding the AVR family

Largely this is still true - I don't know of an ARM in a dip format, and the adapters make it significantly more expensive than the AVR. For the most part, manufacturers don't think that a DIP packaged 32 bit processor is going to be very profitable.

I know you said "other than cost", but really that is the most important thing for hobbyists. You don't need more than one UART or more than one SPI on what is meant to be a cheap, generic platform. Once you start needing >20mhz speeds, you really should be looking at a custom setup (ymmv of course)

I agree with the dip package, disagree that arms are harder to configure, lpcs are, but they are not the only kid on the arm block (atmel itself for that matter). From what I remember and experienced, Atmel was and perhaps still is just more developer friendly. The AVR butterfly helped them greatly to get more users to their already good sized and happy user base. The PIC was just painful in a lot of ways, the avr tools were there, programming was a breeze and didnt cost you much more than some wires and a connector from radio shack. The tools are there and free but not as easy as mainline gcc where you find the arm and thumb solutions. Long before the arduino came out the AVR was the chip of choice for hobby projects.

Nothing can compete with ARM right now. For ever other processor you touch in a day you touch a few ARMs at a minimum. For some almost everything you touch uses an ARM. It is a natural fit as the 8 bit killer, can get much better performance than an 8 bit for the same size, price, etc. Tools are much better, instruction set is much cleaner than most of its competition so the same code runs that much faster, etc. Because anyone and their brother can embed an ARM and it is not locked into a company like pic, avr, msp430 there are a wide variety of solutions, and as many different ways of dealing with the microcontroller rom/ram mixtures and the interrupt vector table. Sadly the more popular solution is the most painful. Try a sam7 or something like that or a stellaris. There is an armmite pro which is an attempt to make an arm based arduino plugin, or something close to that and I actually like that board.

It isnt always the processor that is the problem, some chips have known can problems, some have other known problems. some may not offer a open collector io pin with a weak pull up and you would have to put hardware outside the chip to interface to something, where another may have that available on one or all of the pins. I recommend sampling the field, trying the different companies and solutions so that when you want low power you can easily use a msp430, you want processing power in a small chip you go with arm or if you want to make an open project that you hope others will build in their garage you base it on an arduino, if you can.

The bottom line though for your question is it really depends on your application and how you write it and the performance and resources you are interested in. In the same way that gcc or firefox will run on many different platforms and processors, you most certainly can write your C application to run on a wide variety of microcontrollers...IF...you have a microcontroller specific abstraction layer, which has a cost. if the microcontrollers have similar enough features and have the features you need and you plan ahead and incorporate those. If the next platform has enough memory/resources. You are more interested in portability than performance, etc. Arguably you need to plan for this ahead of time. or at least on the first switch from A to B you re-design the software, if/when there is a third switch from B to C it is less painful.

A major advantage to the ATmel uCs is that there is a free compiler available for Linux, PC and MAC. Add to that a simple cross-platform GUI and you have a free development system that runs on all platforms.

Cost is a major factor for the hobbyist boards. Since you want to have a starter price in the $30 range you need to have a uC cost that is no more than a couple of dollars.

ARM would be a excellent candidate for the higher end boards. A lot of companies license the ARM core and add peripherals. I believe there are free compilers for Linux, PC and MAC.

I really like the Freescale Coldfire for high end boards. I worked on a board for test equipment that used a 5206e. We added some DRAM and high accuracy A/D and D/A converters. It was a cost-effective solution. I have not recently compared Coldfire to the wide variety of ARM's.

Some of the 8-bit Freescale uCs are nice but I am not sure if they have free tools.

(* jcl *)

www: http://www.wiblocks.com

twitter: http://twitter.com/wiblocks

blog: http://luciani.org