I am very interested in the following ARM Cortex-M0 microcontroller:


However I'm turned off at the thought of having to license their development software, which I found here: http://www.lpcware.com/lpcxpresso

Do I have options? My goal is to PCB design a custom development board based off of this microcontroller or similar (Cortex-M0/M3), and be able to program it via (micro) USB. Frankly I'd rather write ARM assembly - and likely be able to find good open source stuff to get me started - than have to use a proprietary IDE.

Thanks for any help; also open to alternatives based on my goals.

  • 1
    \$\begingroup\$ To answer your question: Almost never. I haven't found an alternative for xCORE tools though, but they haven't really made me need to look either. \$\endgroup\$ Apr 3, 2014 at 22:11
  • \$\begingroup\$ Oh? Do you have any example tutorials on how to use an open-source toolchain for developing on an ARM Cortex M0? \$\endgroup\$
    – JDS
    Apr 3, 2014 at 22:15
  • \$\begingroup\$ Nope, haven't explored ARM yet (still waiting for my board in the mail). But off the top of my head I'd write a makefile that invokes GCC appropriately and invokes the tool for uploading via ISP/JTAG. \$\endgroup\$ Apr 3, 2014 at 22:19
  • \$\begingroup\$ github.com/dwelch67/stm32f0d and the build_gcc directory as well you only need to build binutils not gcc if you want assembly. \$\endgroup\$
    – old_timer
    Apr 4, 2014 at 0:49

4 Answers 4


The free GCC toolchain supports ARM/Cortex just fine. Pre-compiled versions can be found all over the web, or you can build your own. You could do assembler if you want, but I would suggest at least C, personally I like C++ even better because it allows very efficient libraries.

The things that 'hang around' the compiler can be a bit trickier. I wrote my own make scripts, linker scripts, startup code, and some support libraries. That requires some in-depth knowledge, but it is not that much work (at least for the first few chips). I mainly use the LPC DIP chips, LPC1114FN28 and LPC810M021FN8.

I am not a fan of the 'heavy' IDEs. I use mostly PSPpad, but the make-script can be used with any editor that can call a shell script, catch the output, and parse a (GCC) error message.

I am not a fan of debuggers, I prefer to insert print statements. I use lpc21isp for hands-off serial downloading + terminal emulation. Works OK, except that I had to patch lpc21isp it to reset the chip after downloading (instead of using the ISP GO command, which is broken on Cortex. Blame on you NXP for not fixing this!).

An article about how I use C++ can be found here.

In about two weeks I'll have my environment up-to-date for my C-on-LPC1114 course. The last-year version can be found here.


Yes, you have many options. I've been programming Cortex-M0 and Cortex-M3 processors from NXP and ST using open-source tools for years. ARM maintains a version of gcc that cross-compiles at launchpad.com. You can use Eclipse as an IDE. To do it right you need a Single-Wire Debugging interface. I use the Segger JLink but there are other options for that as well.

Some time ago I wrote a paper about putting all of this together for teaching a microcontroller course. There is also a great deal of useful information at Yet Another GNU ARM Toolchain.

  • \$\begingroup\$ Wow sweet! Your paper seems to be exactly what I'm looking for, even with the same MCU. A quick question - if I follow a schematic similar to this (soldersplash.co.uk/docs/DipCortexSchematic1.3.pdf) as a starting point, I would be able to program directly over USB with the drag-and-drop file method into its flash? \$\endgroup\$
    – JDS
    Apr 3, 2014 at 22:37
  • \$\begingroup\$ Sorry, I don't know the LPC11Uxx processors. You might look for a similar board from Olimex or one of the LPCXpresso boards and make sure the USB is connected the same way. While you can program via USB it really limits your ability to debug. Using gdb over the SWD interface is pretty awesome. \$\endgroup\$
    – Joe Hass
    Apr 3, 2014 at 23:01
  • \$\begingroup\$ @JoeHass Would you put this combination of open-source tools at a comparable level to toolchains such as Code Red or Sourcery Codebench or Keil for commercial development (where time is definitely money and optimization might be fairly important)? \$\endgroup\$ Apr 4, 2014 at 1:30
  • \$\begingroup\$ @SpehroPefhany This isn't the place to offer opinions about commercial products...I won't get into that. As for the time/money tradeoff, the OP seems to have more of the former and less of the latter. \$\endgroup\$
    – Joe Hass
    Apr 4, 2014 at 11:08
  • \$\begingroup\$ @JoeHass Okay, I kind of expected that response. Last time I looked it was really hard to find head-to-head comparisons, as well as hard to find tutorials such as yours. Thanks for making it available. I'll ask in Usenet and reference your work if you don't mind. \$\endgroup\$ Apr 4, 2014 at 12:16

Most, if not all IDEs are presentation devices for editors, makefiles, compilers, linkers and debuggers that conveniently build-in but hide the command-line details of operation so you don't have to think about those. They usually expose the details for you to modify or replace, so you can almost use your choice of IDE with any toolchain you have access to, such as the gcc set Wouter referred to.


LPCXpresso is an Eclipse-based front end for a build of the arm-non-eabi-gcc toolchain, plus some other glue, libraries, demos, etc.

A free license with moderate code limit is available by registration.

But NXP does not own Eclipse or GCC apart from their own modifications, and for GCC the license even compels them to provide you source code for the exact version they use. Nor can they place legal usage restrictions on GCC (ie, they could add a code size restriction in their customized source, but you can also comment that back out - though the restriction may well not be in the compiler at all)

Using LPCXpresso appears to be entirely optional - the included GCC build is usable from the command line, and the IDE even appears to generate makefiles which can be used to rebuild your project without running the IDE again, provided you specify the location of the compiler. You should also be able to learn enough from these to create projects from scratch without running the IDE at all.

It's probable that upstream arm-gcc would be able to target the chips; if not, a determined person could figure out whatever is changed in NXP's GCC sources and upstream that.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.