HELP! What MCU (greater than 8-bits of smarts) is easiest to graduate to?

[charlespax]

I've been having fun with MicroPython. It uses an Arm Cortex M4. When I was single I made a MicroPython robot running some rather complex AI to help me .

[SuzyC]

Thanks Charlespax,

I think I saw at a local electronics store that they were selling Rasberry Pie mcu kits using Python to code them with, something a little too cute to play with, with WiFi and GNW?

Seems too odd a programming language use to me for hardware on the MMMMM level.

The board you show may not be so easy to find in production now, according to my fast search of the web.

[westfw]

I am not looking for an Arduino experience, I wanna learn about how to program these chips register by register

One problem is that the ARM vendors would have you use their "peripheral libraries", which while they are more complicated than Arduino libraries, aren't really a lot better at exposing "register by register" programming.

regarding programming the Cypress ARM
Can anyone tell me if any of it is anything worthwhile/a bargain/stay clear of?

Be careful of what you're getting.  Cypress "PSoC" chips are available with 3 different CPUs.
PSoC1 chips has a proprietary Cypress core, the 8bit m8C.  I haven't heard much good about it.
PSoC3 chips had an 8051 core.  SOOO 1980s...
PSoC4 has an ARM CM0 core, and PSoC5 has an ARM CM3 core; these are the ones worth consideration, IMO.  A lot of people have been experimenting with these cheap breakout boards (http://www.cypress.com/?rid=92146 ) and or the "Arduino-shield compatible" "Pioneer" board: http://www.cypress.com/?rid=77780

(No need to go searching eBay for bargains...)  (Search the forums here for earlier discussions...)

[Corporate666]

Suzy,

Allow me to humbly suggest the Cypress PSoC line.  I see someone mentioned it before - I am a huge fan of these chips.  I used to use all Atmel but after some bad experiences, I jumped into Cypress.  I could not be happier with them.  I am not aware of all the features of every other chip (so some of the things below may not be specific just to the PSoC chips), but some things I like are...

-Awesome debugging.  You can step through your code and watch the output pins change and monitor memory locations and variables while stepping.  Makes debugging a breeze.

-Cost.  PSoC3 and PSoC4 chips are pretty powerful (8051 and ARM M0 cores, respectively) but they are in the $1-5 range in small quantities.  Plus they are available from most sellers, and direct from Cypress too.

-Flexibility.  Most chips will have, say, an ADC on one pin, an interrupt capture on another pin, and UART on another pin.  With the PSoC, you drag-and-drop the digital and analog perpipherals you need and you choose which pins those peripherals run on.  Cypress also has great libraries so instead of messing around with calibrating an ADC and using a table or calculation to get a result, you can configure the peripheral to give you the value in the format you want.  So if you are measuring temperature, you could configure it to give you a result in degrees fahrenheit, for example.

I have in my hands a CY8CKIT-049-42XX.  I think they cost around $5 or so.  It's a small board with a USB connector on one end, a PSoC4 on it, a switch and LED, and then just pin header sockets all the way down the board in DIP format.  So you can plug it into your computer and play around with making programs and debugging... and/or you can solder pin headers to it and use it in a breadboard. 

The only downside to Cypress stuff is that because it is not as popular in the hobbyist world, there are less code examples and forums than there are for PIC and Atmel, for example.  But Cypress is making a big push to support the users, so you can go right to the forums on the Cypress.com website and get answers to programming questions right from the company itself, which is pretty awesome.

One other thing - IMO, stay away from PSoC1.  It is the first generation of the MCU+PLD concept... it's old tech and being phased out.  It doesn't have near the configurability of the later PSOC3, 4, 5) chips, and since the PSOC4 came out, they are actually cheaper than the less powerful PSoC1... so IMO no reason to bother with PSoC1, use the later ones.

I don't work for Cypress or have any connection to them, other than being a very satisfied customer.  They have gone above and beyond in giving me samples, dev kits, answering questions and supporting me in my projects. 

[zapta]

Thanks Zapta!

I clicked on the link you posted and got this chip pop up at Farnell. It is cheap enough and fast but I couldn't find a link to buying the development board. When I clicked on "order" I got the link to the chip itself at Farnell.

NXP  LPC11U12FBD48/201,  MCU, 32BIT, CORTEX-M0, 50MHZ, LQFP-48

also LPCXpresso Board for LPC11U14 is quite inexpensive and uses JTAG.

Ummm I wonder what JTAG is and how to I work with it?  I have a ATMEL AVR MARKII Main uni usb  to 6-pin header made for the ATMEGA2560 and other ATMEL chips  to directly bypass the Arduino bootloader and download my programs. But would  NXP/TI or Cypress support this USB intergace??? What's a mother to do???

SuzyC, I think this is the entry in Farnell

http://uk.farnell.com/nxp/om13014-598/kit-dev-lpcxpresso-lpc11u14/dp/2251822

Don't worry about the jtag stuff. Everything just works. The board has two halves that you can be broken apart (but don't do it until things work for you).  One half is the debugger and one half is the target ARM board. Install the LPCExpresso IDE on your OS of choice (Windows, Mac or Linux), download their examples, connect the debugger half to your computer with a standard Mini B USB cable and everything should work, including single step debugging, and register and variable examination. No external power is necessary.

Once the basic stuff works for you and you want to embed it in your project (or design a custom PCB based on the ARM board half), hook the debugger to the target board using a 8 wire cable and then you can debug your own board.

Notes:
1. The board, even before you break it, should fit on a solderless breadboard (you need to solder the 0.1" header, similar to what is done with Arduino's breakout boards). This way you can hook peripherals while experimenting.

2. My board arrived from Digikey with a USB connector also on the target half. I guess this is to experiment with targets that talk USB. Am not sure what part number is what. Mine says "LPC11U14 REV A (c) 2011" on the target half. I got it from Digikey a few weeks ago.

3. NXP has support forums where you can ask questions and get them answered.

4. I am not claiming that this combination is 'the best'. I was just looking for a reasonable one that is easy to install on mainstream OS's, works out of the box with a single install, and comes from a known vendor, just the same experience I had with Arduino. This makes open source project more open and easier to modify by others.

[miguelvp]

The only downside to Cypress stuff is that because it is not as popular in the hobbyist world, there are less code examples and forums than there are for PIC and Atmel, for example.  But Cypress is making a big push to support the users, so you can go right to the forums on the Cypress.com website and get answers to programming questions right from the company itself, which is pretty awesome.

Google: 100 projects in 100 days
element 14 did a series of projects based on the PSoC4 targeted to the pioneer board ($25 with arduino headers) and it also has a PSoC5LP that acts as the bootloader but it can be used as well.

The projects should translate well to the prototyping boards ($4+ shipping)
you can buy chips in QFP or QFN or SSOP for $1 each no minimum and free shipping (PSoC 4200)

It's very easy to use and flexible power inputs plus programmable digital and analog makes them pretty powerful.

PSoC 5LP is better, smartchboards has some breadboard ready for $35, there is also a kickstarter that will expand the R-Pi using the 5LP.

[nctnico]

IMHO hunting for the cheapest development board or device is not the way to go. Better spend a little bit more on a device which is easier to use.

[djacobow]

Doesn't 32-bit programming require that every mcu instruction uses 4x the program memory than an 8-bit MCU? How do I learn to graduate from an 8-bit char variable mentality to the 32-bit world of the ARM?

I didn't see anybody answer this yet. The answer is, no; the instruction size is not necessarily tied to the machine word size. For ARM the basic ISA does have all 32b instructions, but all M* processors have the "Thumb" and "Thumb2" modes, which provide 16b instructions, allowing the compiler to select small versions of the most common/important instructions.

Basically, your code may bloat compared to Atmega 8b AVR which has 16b instructions, btw) but it will not bloat 4x.

[SirNick]

You're going to get different answers every time you ask "What board should I buy?" so at some point you're going to have to make up your own mind.  Do it based on detailed descriptions of the differences, or based on tutorials you find, or because NXP offers a turn-key system, or because the ST chips are someone's darling, or because you like Atmel's AVRs and want to try their SAMs.

When you're just starting out, it doesn't really matter much, so you won't get it "wrong".  You're not invested and can hop trains at any time.  You're just out a few bones and some time if it doesn't work for you.  Several manufacturers make Cortex M0, M0+, M3, and M4 MCUs.  Pick one -- preferably an M0+ to start since they're simple and cheap.

Here are a couple options though:

http://www.adafruit.com/products/1336 -- This is a breadboard-friendly starter kit.  You get a bare NXP LPC 810 in DIP-8, a USB to TTL serial cable, and a handful of parts for $13.  Or buy the parts alone from your favorite supplier.  Adafruit has a tutorial on getting started with this kit, which should make it easy to dip your toes into the ARM pool.  It won't get any easier than this.

http://www.adafruit.com/products/1341 -- This is one of the bigger(ish) NXP LPC Xpresso dev boards.  I got one similar to this, if not the same one, from Digikey a little while back.  It's made to be plug-n-play with the LPC Xpresso IDE and community.  If you want community support, NXP would be a good vendor to choose.  Likewise, if you want to dive into the deeper end of Cortex M-series, this would be a decent model to start with.

NXP is one of the more popular vendors along with ST, so it would be wise to narrow your list down to those two unless you have reasons otherwise.  The Atmel offerings are not exactly stellar (some of the NXPs are faster) but their docs are pretty good, and probably feel more familiar to an existing AVR user.  If you want to go that way, you might begin with the Arduino clones that use the SAM chips under the hood.

I would leave Cypress and TI and all the others alone until you have enough experience to decide whether they have something unique to offer.  But, that's just my opinion, and you know what they say about opinions:  Everyone has one, and no one else wants to hear it.

[SuzyC]

SirNick, thanks for your opinions!

I personally truly think that everyone has an opinion and I want to hear all of them!

I am going to try to take a look at your hardware suggestions.

Right now I have a pile of printouts about various ARM chips and boards and LPC and I gotta figure out which path to take,
 

[SuzyC]

Thanks djacobow,

For answering my question about the amount of programming memory used on 32-bit chips per instruction.


I have just completely ran out of memory on my MASTER 16F886 mcu, so something new and more powerful has to be found.

[Jeroen3]

I wanna learn about how to program these chips register by register to get my thingees to work!

Be careful what you wish for.
I can recommend you this book. http://www.google.nl/search?q=The+Definitive+Guide+to+the+ARM+Cortex-M0 With their sequels for the Cortex M3 and 4.
This is also a good place to add to your bookmarks for all kinds of stuff. http://infocenter.arm.com/help/topic/com.arm.doc.set.cortexm/index.html

Basically, your code may bloat compared to Atmega 8b AVR

The available flash also grew in numbers. Thumb mode is used for 16 bit instructions (including 16 bit data) on a usually 128 bit wide flash for faster fetching. (read that book)

To answer your question "What board should I buy?": a board you can afford. Try getting into the serious Freescale parts, or get a Keil demo board, maybe get a loan first.

Of my experience with NXP (11xx, 17xx and 43xx) and STM32F0 and F4's. I can recommend NXP for starters with bare metal programming. NXP uses relatively simple peripherals so a timer consists of a control, counter, compare. ST tries to fit your entire application in a single pair of Basic timers, Advanced timers, PWM timers or you name it. Currently I'm using STM32F4's (ChibiOS ), but I cannot imagine what a pain this must be without peripheral driver code.

The main challenge will be the user manual, where the registers are explained. These differ between vendors and it will definitely take some to time before you read them as comics.

[Kjelt]

I second sirnicks lpc1769 xpressoboard, very nice and worth every penny since you seem to be tight on cash.
It can also be ordered directly from emb. Artists website or farnell 1825878
It can get you started for $30 and if you want further you can expand with base oard etc. It has a 120MHz cortex M3 and 512kB flash should keep you going.
Not satisfied? Anyone will take it of your hands for $15-$20 if still ok, so a good choice to start i think.

[dannyf]

I think you will need to consider the chip, the debugger / programmer, the software and the ide, in making an informed decision:

1) the chip: the core / instruction set doesn't really matter, as long as you code in a high level language like C. I would, instead, look to the peripherals in picking a chip. Make sure that the chip has all the peripherals you possibly need.

Of the most chips people here use, NXP has the least bug, also the least features. ST has the lowest price / flexibility, but somewhat buggy chip. Atmel has well documented chips. TI has the most feature rich chips, but buggy adc.

Most of those chips are LQFP, or worse. Not terribly hand-solder friendly. Some vendors offer TSSOP, or even PDIP (8 or 32 for example).

2) the debugger / programmer: most of those chips can be programmed with "universal" debuggers like j-link (fairly pricey), or vendor-supplied debuggers, like LPCLink, redlink, or st-link. They are much cheaper, especially if you buy clones, and sometimes integrated into the dev boards.

3) the software: if you take a look at the datasheet, those chips have vast number of registers. Many times, you may find it beneficial to use vendor-supplied libraries to simplify the process. Vendor support there ranges from non-existent (almost, like NXP), to somewhat good (ST or TI), very good (Atmel), to excellent (Freescale).

4) the ide: most vendors offer some limited versions of keil or iar, typically limited to 32KB. Two excellent choices are KDS (freescale) and CoIDE - free and unlimited and superb project wizard.

[dannyf]

I would just add that your experience with ARM will depend critically on your ability to program - being comfortable with managing a multi-module project, being able to connect seemingly unrelated dots, being proficient with a modern IDE, .....

To provide you an example, a typical blinky project for me contains about 1000 files and takes up 35MB. The actual code that blinks the LED has maybe 3 - 5 lines and the main() is less than 10 lines. 99.99% of the code in that project is canned and borrowed from prior work or written by the vendor.

So if you aren't sure of your ability to handle that kind of programming, I would suggest that you start with a low-cost, all-in-one package, like one of those ST Discovery boards. They contain a hardware debugger, a chip + some indicators and sometimes sensors. They are also well supported by CoIDE.

Essentially, once you have the board, you just need to download CoIDE and you are ready to go.

The prices ranges from < $10 for the STM32F0 boards to the < $20 for the STM32F3 and then $20+ for STM32F4 boards. Tough to go wrong with those.

If you are into multi-copters, I would recommend the STM32F3 discovery - it has an onboard accelerometer, gyroscope and compass, plus FPU.  Plus tons of flash / memory and lots of speed.

All for just over $10. Very difficult to resist at that price point.

[zapta]

This thread demonstrates the Android proposition of a simple introduction to embedded programming.

[SirNick]

Well... careful with trying to start with a chip or board that is out-of-the-box suitable for your project goal.  That makes it tempting to try to learn on-the-fly while also trying to accomplish something useful.  Don't do that.  For a while, you need to focus on learning the ropes.  Blink some LEDs, read some switches and knobs, etc.  Unless you're an expert (and if you were, you wouldn't need our advice here) trying to pull off too much too fast is going to end in frustration.  Crawl, walk, run -- in that order.

The IDE issue confused the heck out of me for a while because it's not often you get much of a choice in 8-bit land.  If you think you got impassioned responses over which MCU to use, try asking about IDEs...

Basically, you should be able to use GCC (if you're willing to set up your own cross-compiling environment), the vendor's own toolchain (e.g., LPC Xpresso), or a third-party IDE like IAR, Keil or Kuckoo.  That other new paradigm -- limited code size or trial periods -- is something else you'll have to deal with.

The vendor environment might be best to start with since they will have provided Getting Started guides, videos, and forums under the assumption that you'll use their canned solution.  The third-party offerings try to be somewhat (MCU) vendor-neutral, but you might have to put in a little effort getting it to work with dev boards and their integrated debuggers.  At some point, you'll just have to try out different options until you find the one you like.  Watch some YouTube videos featuring different IDEs to get a feel for that.

The sheer number of options was the single hardest thing about breaking into ARM development IMO.  It's a fragmented space without a lot of clear direction at first.  You really just have to dive in and acclimate for a while.

[22swg]

PIC24FV32KA304 with BOB MPLABX  XC16  PICkit3   

[SuzyC]

Thanks to Everyone!

Here's what I've got to wrap my head around:

Danyf::

 1) ARM: a lot bigger chips and far more powerful peripherals. Much steeper learning curve and a new set of tools and a new approach to programming. Rarely they are 5v compliant.

2) PIC24 (including the dsPIC chips too): more processing power, slightly steeper learning curve, and similar tools. Marginally more complex peripherals. Many are 5v compliant. Unknown future.

3) advanced 8051: some firms, like Silabs, make amazingly fast 8051 loaded with features. The high end ones surpass many ARM chips in terms of processing power. New tools to learn.

Take a look at the various STM32 copter control boards and see for yourself how little you need for 5v in today's environment.
--------------------------------------
Mikeselectricstuff:

PIC is the only option for higher-end parts in DIP - PIC24 and PIC32 are available in DIP, SOIC, SSOP and QFN. And I mean actually available
Most have some 5V tolerant pins if you need it - there are one or two PIC24s that run on 5V.
Many peripherals and devtools will be pretty familiar if you're already using 8 bit PICs
--------------------------------------
22swg:

PIC24FV32KA304 with BOB MPLABX  XC16  PICkit3
--------------------------------------
fcb:

dsPIC30 family if you really must use 5v.

then migrate to dsPIC33F and dsPIC33E families when you need 3v3 and a bit more grunt.

Learning curve isn't that steep if your used to microchip stuff already
--------------------------------------
Zapta:

I had the same dilemma recently and settled on NXP M0 ARMS. One strong point for me was the availability of a simple to install tool chain. They packed Eclipse and all the plug ins and tools into a single and free package LPCExpresso that installs on Mac, Window and (I think) Linux  http://www.lpcware.com/lpcxpresso.  You can user everything interactively from the GUI or set your own makefile if you prefer.

For example get this board http://www.nxp.com/demoboard/OM13014.html  (~$15), hook it to your computer and you can start edit, run and debug (full feature debugger).

(mini rant: I hate complex to install tool chains, especially if I need to download different parts from different web sites or compile the source on my machine (which typically fails with cryptic error message). Single package install is the way to go.).

(and a little later this post:)
http://uk.farnell.com/nxp/om13014-598/kit-dev-lpcxpresso-lpc11u14/dp/2251822

Don't worry about the jtag stuff. Everything just works. The board has two halves that you can be broken apart (but don't do it until things work for you).  One half is the debugger and one half is the target ARM board. Install the LPCExpresso IDE on your OS of choice (Windows, Mac or Linux), download their examples, connect the debugger half to your computer with a standard Mini B USB cable and everything should work, including single step debugging, and register and variable examination. No external power is necessary.

Once the basic stuff works for you and you want to embed it in your project (or design a custom PCB based on the ARM board half), hook the debugger to the target board using a 8 wire cable and then you can debug your own board.
--------------------------------------
Jeroen3:

 As beginner you should focus on Cortex M chips only.
If you're looking for a plug&play experience as Arduino you should definitely look at mbed. Or an STM32 with ChibiOS, but the latter might complicate things a bit too much I think.
(and in a subsequent post:)
Of my experience with NXP (11xx, 17xx and 43xx) and STM32F0 and F4's. I can recommend NXP for starters with bare metal programming. NXP uses relatively simple peripherals so a timer consists of a control, counter, compare. ST tries to fit your entire application in a single pair of Basic timers, Advanced timers, PWM timers or you name it. Currently I'm using STM32F4's (ChibiOS ), but I cannot imagine what a pain this must be without peripheral driver code.
--------------------------------------
dgtl:


So the simplest way to get started would be:
* buy an LpcXpresso board (doesn't matter which... but unless you need to try a specific uC, get the biggest one you can... the price difference is almost nothing but you'll get 10x more flash space and many more peripherals to play with. For example, 15xx and 17xx are nice to play with.)
* install lpcXpresso software
* connect the board via USB to the PC
* create a new example project (use the blinky demo, for example)
* press the debug button to upload to uC
If you need more HW, get an Embedded Artists Base Board; the lpcXpresso plugs into that and you'll have plenty of things to play with.
---------------------------------------
Westfw:

Be careful of what you're getting.  Cypress "PSoC" chips are available with 3 different CPUs.
PSoC1 chips has a proprietary Cypress core, the 8bit m8C.  I haven't heard much good about it.
PSoC3 chips had an 8051 core.  SOOO 1980s...
PSoC4 has an ARM CM0 core, and PSoC5 has an ARM CM3 core; these are the ones worth consideration, IMO.  A lot of people have been experimenting with these cheap breakout boards (http://www.cypress.com/?rid=92146 ) and or the "Arduino-shield compatible" "Pioneer" board: http://www.cypress.com/?rid=77780
---------------------------------------
Corporate666:

Allow me to humbly suggest the Cypress PSoC line.  I see someone mentioned it before - I am a huge fan of these chips.  I used to use all Atmel but after some bad experiences, I jumped into Cypress.  I could not be happier with them.  I am not aware of all the features of every other chip (so some of the things below may not be specific just to the PSoC chips), but some things I like are...

-Awesome debugging.  You can step through your code and watch the output pins change and monitor memory locations and variables while stepping.  Makes debugging a breeze.

-Cost.  PSoC3 and PSoC4 chips are pretty powerful (8051 and ARM M0 cores, respectively) but they are in the $1-5 range in small quantities.  Plus they are available from most sellers, and direct from Cypress too.

I have in my hands a CY8CKIT-049-42XX.  I think they cost around $5 or so.  It's a small board with a USB connector on one end, a PSoC4 on it, a switch and LED, and then just pin header sockets all the way down the board in DIP format.  So you can plug it into your computer and play around with making programs and debugging... and/or you can solder pin headers to it and use it in a breadboard.

The only downside to Cypress stuff is that because it is not as popular in the hobbyist world, there are less code examples and forums than there are for PIC and Atmel, for example.  But Cypress is making a big push to support the users, so you can go right to the forums on the Cypress.com website and get answers to programming questions right from the company itself, which is pretty awesome.
---------------------------------------
Miguelvp:

Google: 100 projects in 100 days
element 14 did a series of projects based on the PSoC4 targeted to the pioneer board ($25 with arduino headers) and it also has a PSoC5LP that acts as the bootloader but it can be used as well.

The projects should translate well to the prototyping boards ($4+ shipping)
you can buy chips in QFP or QFN or SSOP for $1 each no minimum and free shipping (PSoC 4200)

It's very easy to use and flexible power inputs plus programmable digital and analog makes them pretty powerful.

PSoC 5LP is better, smartchboards has some breadboard ready for $35, there is also a kickstarter that will expand the R-Pi using the 5LP.
---------------------------------------
SirNick:

http://www.adafruit.com/products/1336 -- This is a breadboard-friendly starter kit.  You get a bare NXP LPC 810 in DIP-8, a USB to TTL serial cable, and a handful of parts for $13.  Or buy the parts alone from your favorite supplier.  Adafruit has a tutorial on getting started with this kit, which should make it easy to dip your toes into the ARM pool.  It won't get any easier than this.
http://www.adafruit.com/products/1341 -- This is one of the bigger(ish) NXP LPC Xpresso dev boards. I got one similar to this, if not the same one, from Digikey a little while back.  It's made to be plug-n-play with the LPC Xpresso IDE and community.  If you want community support, NXP would be a good vendor to choose.  Likewise, if you want to dive into the deeper end of Cortex M-series, this would be a decent model to start with.
NXP is one of the more popular vendors along with ST, so it would be wise to narrow your list down to those two unless you have reasons otherwise.  The Atmel offerings are not exactly stellar (some of the NXPs are faster) but their docs are pretty good, and probably feel more familiar to an existing AVR user.  If you want to go that way, you might begin with the Arduino clones that use the SAM chips under the hood.

I would leave Cypress and TI and all the others alone until you have enough experience to decide whether they have something unique to offer.

[SuzyC]

Oh Dear!

I don't know SLP from SLR(my camera)

[zapta]

OP, when you drive toward a fork in the road, often it doesn't matter much if you choose the right or left side, as long as you don't hit the tree in the middle.

;-)

[Jeroen3]

When you drive toward a fork in the road, there is little chance a road will make a u-turn. You might need some course correction in the future though.
Just choose one of the roads your cart seems to fit on, comfortably.

[SuzyC]

I guess that means if I havta choose between SLP and SLR I must at all cost avoid SLQ.

[Corporate666]

I would humbly add that most MCU's are largely similar in how they are programmed, so if you take away "advanced" stuff like memory management, speed, MIPS and the like, it pretty much comes down to the development environment, availability of parts, price of the chips, support and what the chips can do (peripherals).

The basic C code is not going to be much different whether you're using an ARM, 8051, AVR or something else.  What else is available (peripherals) and how easy those features are to use is going to make a big difference.

I hate to keep sounding like a shill for Cypress but I think this is where the PSoC really shines.  You can configure the chip and give your pins names and set them as I/O's and such.  So a program to turn on an LED when a button is pressed becomes

if (Button() == 1) { LED() = 1; }

It's similar when using ADC's, timers, PWM's and such.  Drag and drop them on your design, tell them which pins to input/output to, configure the component and then use the built-in API/library to easily use the peripherals. 

If you get more advanced, you can write your own Verilog and make your own components. 

You don't need to mess with logical operators or setting registers and such. 

[zapta]

I hate to keep sounding like a shill for Cypress but I think this is where the PSoC really shines.  You can configure the chip and give your pins names and set them as I/O's and such.  So a program to turn on an LED when a button is pressed becomes

Can you describe the development environment. Is it free, does it run on Linux/Mac, is it a single package install, does it have decent features (GUI, C code cross reference, debugger, etc).  Cypress is not that popular for ARM (I am relying on that graph in the other PIC vs ARM thread) but maybe just as good. I already got a ST board, then switched to NXP but wouldn't mind to try another one.

OP, another option you have is to wait for the upcoming Arduino ZERO (ARM based) or use the existing Arduino DUE (also ARM based).