Source
r/embedded•
deepcube

Choosing an ARM board without being forced into an IDE

I'm looking for an ARM board that doesn't force me into using their IDE but is still relatively easy to get started writing code to run on bare metal. I want to continue developing on Linux like I normally do, preferably using gcc, but as long as I can throw together my own makefile to compile/assemble/link (and maybe flash) I'm happy. Any suggestions? The shear number of choices boggles the mind, I don't know where to look.

Cheap, low power, and simple are better, but not necessary. No minimum amount of RAM or clock speed. Don't care about word size. Need some gpio pins, rs232 is helpful. My project is building an RPN calculator for now. I have all the parts I need left over from previous things just need a chip or dev board.

I'm also open to other suggestions. I only chose ARM because all the job postings I'm seeing are for ARM (except that one looking for experts in PDP-11 assembly... Amazed that's still a thing!).

Posted Sep 28, 2017, 6:42 PM UTC

1224
_PurpleAlien_•

One word: STM32. Get one of the Nucleo boards for next to no money, and choose if you want to go HAL with Eclipse or CMSIS and Makefiles - or anything in between.

Edit: http://www.st.com/en/evaluation-tools/stm32-mcu-nucleo.html

19
deepcubeOP•

Thanks, googling around now to see if I can find good instructions/examples to set it up.

6
thefirstsuccess•

For super easy setup, go to their Mbed online IDE and just download the project. It has options for downloading it formats for various IDEs, but also just as a Makefile project

4
deepcubeOP•

Reading up I don't think I want to use mbed. I want to be as close to the hardware as possible so maybe CMSIS.

5
Wil_Code_For_Bitcoin•

The cubemx32(code gen) could also help get you going if you decide to go HAL. Really helps setting the clocks, etc

6
thefirstsuccess•

You wouldn't necessarily have to use the Mbed libraries, CMSIS and register-level programming are both valid options. Mbed is just for getting the project and Makefile generated for you with no hassle

3
dmc_2930•

ARM owns MBED, and is pushing it pretty hard. If your goal is to learn something useful in industry, it's worth considering getting familiar with the platform.

3
SmokinGrunts•

I'd like to recommend TI's Tiva line, then. They have stellar documentation, the TI E2E forums for tiva are great (Look for Amit Ashara, or cb1), and you can use anything to develop on them. I've personally used eclipse on both windows and linux, before switching to straight gcc and makefiles on linux. Tiva's are ARM-3 Cortexes. I personally use the TM4C1294NCPDT, and thoroughly love it.

EDIT: From what I can recall, there are guides for Eclipse, TI's Code Composer Studio (simply an eclipse rebrand), the Energia IDE (Based off Arduino's Wiring IDE), Keil Embedded, Code Sourcery, Visual Studio, and there's even GCC guides on their wiki.

2
DoingIsLearning•

GCC?

Very few chips "force" you to use vendor IDE's. Most people use them because of other features such as in-circuit debugging and a plethora of compiler optimizations and assurances (specially in regulated industries).

If you want a 'no thrills' free software toolchain/workflow you can literaly:

  1. Write your source code on a text editor
  2. Compile and build your code on a terminal with gcc
  3. Dump your binary onto your embedded target, with a vendor compatible ISP programmer.

For reference, you are not locked to ARM Cortex chips, here is a list of gcc supported targets:

https://gcc.gnu.org/backends.html

16
Madsy9•

No boards forces you into an IDE unless it requires some strange proprietary protocol for flashing it, and even then you only need it for uploading your binary. As long as you have CMSIS-DAP support over JTAG or SWD, you're good to go. Use the arm-embedded-gcc compiler for compiling code and OpenOCD for debugging and flashing. Any ARM-based board from Atmel or TI should work fine.

7
HeroOfCanton•

Literally any of them plus the GNU ARM Embedded Toolchain.

5
Sylph•

Platformio supports a fair few ARM boards without forcing you into any IDE (providing you just use the core). It does sometimes force you into specific libraries or even toolchain components, though you can usually get around that with some hacking/customisation.

3
playaspec•

+1 for PlatformIO. It's very flexible, highly productive.

1
AustinSpartan•

FRDM-K64 with MCUXpressoSDK using the command like gcc toolchain. Contains bare metal and FreeRTOS enabled drivers and well supported by pyOCD for debugging purposes. This will be the closest to your Linux dev environment you're used to.

2
markrages•

I like the "STM32F103C8T6 Minimum System Development Board" that you can get off of eBay for about $5. This board is ready to go with USB connectivity for communication and power.

For programming the board get a Black Magic Probe. You can actually load Black Magic firmware on the dev board I mentioned but it's a tight fit, so start with a legitimate Black Magic Probe. The firmware for the blackmagic is open source, and is very well written, and comes with a high quality library for STM32 peripherals, so read through it carefully. It would make a good starting point for the fiddly chip-specific driver bits of your project.

Structure the RPN part of your project as a library so you can debug on your desktop. It's gcc/gdb either way.

ARM is the correct choice for you. You will not be tied to a specific manufacturer, and GCC and GDB for ARM are high quality and just an "apt install" away.

1
duskwuff•

If you don't want to pay for the Black Magic Probe, you can also get an ST-Link v2 clone for super cheap (under $5). They're compatible with OpenOCD.

2
ajpiko•

any chip

1
jabjoe•

A cheap Raspberry Pi? A Pi Zero is very cheap.

No Linux forces an IDE on you. You are alwaya free to use vim or any editor the gcc and make. An lot of stuff is done like that. IDE are except in Linux not the normal.

Edit: Edit: oh wait, I see as build machine but not target. You could still use a Pi. Something that the Pi boot loader boots directly.

-6
_PurpleAlien_•

Think he meant using Linux as the development machine, not the target.

4
jabjoe•

Of course. I use it as both every day. Have done for quite a few years now. Developing on Linux for Linux is the best way. A Pi is a perfectly acceptable development environment. Raspbain is basically Debian so has a whole world of libs and tools.

Edit: oh wait, I see as build machine but not target. You could still use a Pi. Something that the Pi boot loader boots directly.

-1
duskwuff•

The Raspberry Pi is not suitable for bare-metal programming.

-1
jabjoe•

I'm sure there simplier boards. You clearly can do it on the Pi. But yer, I got the wrong end of the stick.

1
duskwuff•

The problems with using the Pi for bare-metal aren't just about simplicity. What's much worse is that there is almost no public documentation for the part. There's a single 200-page PDF giving basic information on some of the ARM peripherals for the BCM2835 (original Pi), and that's it. There is no public documentation at all for the BCM2836 and BCM2837 used in the Raspberry Pi 2 and 3, so using those parts for bare-metal involves a lot of guesswork.

2
jabjoe•

Well yes, often pointed out, fair enough. But there is source code, Linux, U-boot, RISC OS, etc.

1