Herramientas de desarrollo ARM Cortex-M3?

Estoy planeando migrar a la arquitectura NXP Cortex M3 y estoy un poco perdido entre las herramientas de desarrollo existentes.

Keil es caro y no sé si vale la pena. ¿Alguien que haya probado algún compilador puede dar algún consejo?

I found this compiler http://www.code-red-tech.com/red-suite-2.php it seems good and not expensive. Anyone who tried it or know about it can give me more info?

I have been playing with an STM32 (also Cortex M3) lately in my spare time and using the CodeSourcery distribution of GCC, which has worked out pretty well.

A colleague who has worked with ARM micros professionally in the past told me that he was satisfied with the IAR toolchain, although I don't know what the cost is like or how the Cortex support is.

I use the CodeSourcery (Lite) cross-compilers for Linux to program the TI Stellaris Microcontrollers. They work with any Cortex-M3. They're completely free, with binaries for Windows and Linux.

Here's a short recipe (Debian/Ubuntu) to install:

Download the toolchain (any version will do, but I use this one)

Install Java Runtime Environment (for the damned installer)

sudo apt-get install sun-java6-jre ia32-libs

Install

chmod 755 arm-2009q3-68-arm-none-eabi.bin
./arm-2009q3-68-arm-none-eabi.bin -i console

Add cross compiler bin directory to your PATH

echo 'export PATH=$PATH:~/CodeSourcery/Sourcery_G++_Lite/bin/' >> ~/.bashrc 
. ~/.bashrc 

To load code and debug, you'll need OpenOCD and either gdb or one of the GUIs.

You'll also need a JTAG adapter.

I've started using one of these (MBED developer board). The big selling points for me were that I could code in C or C++, straightforward connection vis USB and a slick on-line development environment (no local tool installation required at all!).

http://mbed.org/

Five minutes afer opening box I had a sample blinky program (the 'hello world' of the emedded world) running the following:

#include "mbed.h"

DigitalOut myled(LED1);

int main()
{
    while(1)
    {
        myled = 1;
        wait(0.2);
        myled = 0;
        wait(0.2);
    }
}

That's it! Above is the complete program!

It's based on ARM Cortex M3, fast and plenty of memory for embedded projects (100mhz, 256k flash & 32k ram). The online dev tools have a very good library and plenty of examples and theres a very active forum. Plenty of help on connecting devices to MBED etc

Even though I have plenty of experience with embedded systems (ARM 7/9, Renases M8/16/32, Coldfire, Zilog, PIC etc) I still found this a refreshingly easy system to get to grips with while having serious capability.

After initially playing with it on a basic breadboard I bought a base board from these guys: http://www.embeddedartists.com/products/lpcxpresso/xpr_base.php?PHPSESSID=lj20urpsh9isa0c8ddcfmmn207. This has a pile of I/O devices (including a miniture OLED and a 3axis accelerometer). From the same site I also bought one of the LCPExpresso processor boards which is cheap, less power/memory than the MBED but perfect for smaller jobs (still hammers the crap out of PIC/Atmega processors). The base board supports both the LCPExpresso and the MBED. Purchasing the LCPExpress processor board also got me me an attached JTAG debugger and an offline dev envoronment (Code Red's GCC/Eclipse based dev kit). This is much more complex than the online MBED dev environment but is a logical progression after you've gained expeience with the MBED.

With reference to my original point noite that the MBED controller is much more capable than the the LPCExpresso controller BUT is much simpler to use and learn with.

code sourcery lite is good, or use emdebian. or roll your own, it is pretty easy unless you need a full C or gcc library then it is still doable but a little harder. at first you wont need a thumb2 capable compiler, thumb will do as you search for a toolchain you like.

llvm is another good one (use clang not llvm-gcc!!), I know the arm side is getting better all the time, version 27 produced faster code than the current gcc for a particular test. I found a bug in the thumb side when working on my thumb emulator (thumbulator.blogspot.com) which was promptly fixed. The best part about llvm is it is by default a cross compiler, no extra work or building experience required. In the next few years I see them cutting deeper into gcc in and passing gcc by for cross compiling/embedded.

I tried the code-red tool once with the lpcxpresso board, the end result is I am definitely never using code-red and am debating whether to also blacklist lpc. ymmv. If you have to use a pay for tool I would go with keil only because they were bought by arm and part of the package is the rvct compiler. Of course code sourcery is a pay-for house too if you dont meet the lite limitations or choose to get support, being gcc it has the best support by far of all compilers. Not long ago when I was able to try them metaware and arm's tools blew away gcc as far as quality of the code produced. gcc is up and down some versions of 3.x produce better code than 4.x, they dont appear to be improving on each release, but they did or perhaps code sourcery added thumb2 support not long ago, which the 3.x versions dont/wont have.

I use Rowley software for ARM and MSP430 development:

http://www.rowley.co.uk

It's excellent. Cortex-M3 is supported.

I use Yagarto + Eclipse + J-link edu debugger. (Gnu toolchain)

http://www.yagarto.de/

I've had pretty good success using IAR compiler/debug chains for my ARM development. They offer relatively stable development tools complete with an Embedded C++ environment (which seems somewhat rare). -- Depending on your codebase size, they also offer great hardware/software "KickStart Kits" with code-size limited versions of their tools.

IAR is excellent, and if you are doing small projects there is a free 32K code-size limited kickstart edition. Size upgrades are however a bit expensive I believe. They also come with tons of good example projects, usually several for each processor family.

I spent the last couple days getting the CodeSourcery GNU toolchain fully set up for the EFM32G micro on OS X. It was worth it. Compared to many of the GUI-based debuggers I've tried (mostly Eclipse-based); Makefiles, GCC and GDB are a dream come true; plus it all works from my Linux or Mac terminal.

The only part that sucks is the J-Link adapter built into the board. J-Link's Windows and Linux GDBServer program is closed source. Even worse, the Linux version is MUCH farther behind. So in order for GDB to work, I have to run a Windows VMWare image whose sole purpose is to run the GDBServer (because the Linux one is broken).

Oh and on top of not working correctly, J-Link's Linux-based GDB server binds to 127.0.0.1 and listens ONLY to packets with that as the dest; so messing with iptables and forwarding is needed to get it to connect from a remote machine. Ridiculous; Segger needs to get their act together.

I use QtCreator and GNU Tools ARM Embedded. Works well.

Advantages:

• Totally free (and open source)
• QtCreator is a great modern C++ IDE with working code completion, symbol hyperlinks, refactoring, etc.
• QtCreator supports bare metal debugging (yes - you can graphically place breakpoints, step code and inspect variables). (Requires JTAG or SWD link to your MCU, but this wasn't nearly as hard as I thought.)
• Not Eclipse or Eclipse-based.

Disadvantages:

• Baremetal support is very new and I had quite a few issues with it - overcome eventually with the excellent help of the author on the QtCreator mailing list.
• Maybe a little harder to set up than Keil or code red.

When everything is set up correctly I can click to create a breakpoint in my code, and then click the "debug" button. It will compile, flash, execute, and pause on the breakpoint in about 5 seconds (and simultaneously make you rage if you ever have to go back to the Arduino "IDE").

I am working on a tutorial for how to set this up with another ARM chip - the Cortex-M0 based nRF51822.

I use CooCox tools, it is excellent but free to use, not any code-size limited. http://www.coocox.org/

I use arm-eabi-gcc and the toolchain that goes with it installed via the summon arm toolchain script. The script sets up the environment for doing bare metal work on the ARM. Its free and open source and all that and has worked quire reliably for me. I've also used IAR for this, and it is certainly better in that it lets you do much more friendly debugging and for doing things the IDE way, but on the whole I feel more comfortable with gcc, if for no other reason because I don't have to justify the expense to anyone.

(I've never really worked out how to use gdb for anything, but Ive never really been used to using a debugger or having one available anyway, so I'm not sure if I'm qualified to judge that bit.)

I use Emprog ThunderBench. It is excellent, probably the best I have ever used.

What I like most about it is that it is, at the same time, a C/C++ ARM cortex compiler, a Debugger and an IDE.