An ARM dev board you can make at home


[BarsMonster] just challenged our conceptions of ARM development with his single-sided development board that’s loaded with an STM32F100 (PDF warning) ARM microcontroller. The board is remarkably simple – just a regulator, resistor and a few caps are necessary to get a $1 ARM μC up and running.

[BarsMonster] gave us a schematic of his board along with the Eagle .brd file of his build. Everything is an SMD component, so except for 9 through-holes, this board can be easily manufactured at home.

While we have seen a few single sided projects at Hack A Day, dev boards made with this technique have fallen by the wayside. This surprises us because single sided boards are easy to make with the various CNC mills we’ve seen.

There are a few great projects out there for the STM32 processor, like a web radio, but [BarsMonster] is having some trouble finding some good libraries for his MCU (specifically STM32 libraries for Eagle). If you know of anything he can do, drop a note in the comments or on his website.

Comments

  1. Roberto says:

    The Linuxstamp remains the only Linux-running board that you can make at home.

  2. Jared Boone says:

    The libmaple should get him well on his way. It’s got support for the STM32F103 processor, which I believe shares a lot of peripherals with the F100.

    LeafLabs libmaple

  3. Simonious says:

    It it silly that I think a 2 sided dremel based cnc, with laser alignement for 2 sided copper clad would be cool? Just clamp the board in with edge clamps, let the thing self align on the edges with a laser and then dual dremels or the like cut your 2 sided board for you. Man that’d be fun to build. Somebody toss me a few grand so I can build this and still afford to eat and stuff. :P

    • Otacon2k says:

      Certainly not sillier than a 2-sided butterknife! Imagine, you could butter your bread in half the time! Better toss ME a few grand so I can reduce bazillions of peoples’ breakfast preparation times!

      (Diclaimer: just kidding, no trolling intended)

    • Abbott says:

      OK, that is a really neat idea. Only problem though is the flexing of the board as you tried to mill both sides at once. Perhaps what could work is making a single surface milling machine that flips the board over automatically, realigns, and keeps going… hmm… I think I have a new project now.

  4. jasong says:

    This is awesome! Someone should come out with a kit and some libraries and people wouldn’t have to piddle around with the 8 bit MCUs anymore. ARM is pimp.

  5. Alez says:

    Yeah, its kinda hidden, here you go:
    http://www.linux-arm.org/LinuxKernel/LinuxM3

  6. Duncan Bayne says:

    Thank you, thank you, thank you for the PDF warning. Those of living in countries with paltry mobile broadband caps don’t appreciate clicking PDF links by accident :-)

  7. RunnerPack says:

    And I thought I got a good deal on my AVR board :P

    I would have at least put a crystal on there, though. It’s only three more (cheap, easy to solder) components, and you can go from 8MHz (the internal RC) to 24MHz. Three times the speed for about $0.50 (even less in bulk).

    Still, it’s a nice proof-of-concept. Makes me want to grab a bunch of those chips and play around… at that price, everything I own could have a 32-bit CPU in it!

    • BarsMonster says:

      Hehe, here is the glory of ARM beef, there is a PLL. So you can get to any clock even with internal RC. You need crystal only if you need accurate clock.

    • bacchus says:

      As you yourself say, it’s a proof of concept.

      There’s a bunch of stuff that would go onto any sort of prototyping board, together with a reduced form factor and some headers.

      It could be a kind of open source post-Arduino prototyping board. Unlikely, I know, but it points the way, and Arduino is beginning to look kind of old fashioned and limited.

  8. Spork says:

    I bought a few of these and designed a thru-hole dev board for it. This is a cool board, a little bigger than mine, but more DIY-friendly. Glad to see people switching to ARM!

    PS Where do you get these for $1? I can only get them for like $2.50 (and be able to afford them in that quantity) Anyone want to buy like 100,000 and sell them at cost?

  9. Drone says:

    Those LinuxStamp boards are outrageously expensive, like $130 bux. For that price I’d avoid the ARM abstraction and get an x86 Geode based Alix board instead.

    The builder of the little board in the foto should remove the solder flux around the MCU. I’ve run into problems with flux left on boards like that, especially with closely spaced traces.

    Linux on an M3 isn’t really a full Linux experience IMHO. The M3 doesn’t have an MMU.

  10. the_h4wk says:

    The lib problem can be easily solved when you use the open-source IDE CooCox.
    (Eclipse based but easy to use)
    http://www.coocox.org/

    It comes with every thing, libs,startup,linker, examples, even a RTOS.
    For most M0/M3

    You need a JTAG tough. Many are supported and there is also the cootag/-ex that you can build your self or buy for 20$ from various Chinese stores .

    I’ve got my dev stuff from Itead and am quite happy with it.
    (They have a small tutorial for Coocox)
    I have tried many different IDE’s for free but Coocox is the most straight forward if you ask me.

    I hope this helps. ARM-Cortex M3 are by the way not so hard to program, but you have to try stuff out and look in the libs.

    When I come make a Blog, I may make are a Tutorial for the basic stuff with Coocox, so that you can see, what I’m talking about.

  11. Christian Black says:

    Any recommendations for programming hardware, bootloading procedure and an easy IDE that would definitely work with this board?

    I would specially like to hear about opportunities to use Pascal or BASIC on the ARM. I have paid my dues using C and assembler for years on 8 bit mcu’s and in my old age I want comfort and convenience.

    • BarsMonster says:

      Can’t suggest any non-C env. Personally, I don’t see much syntax difference between Pascal and C, as long as we don’t need hardcore code.

      I was using Keil IDE with J-LINK adaptor. It allows to write code, compile and debug it. You just connect JLINK connector to board and execute Flash->Download command, and you are done.

      • Christian Black says:

        Thanks for that. I had a Keil kit for the Philips 8051 years ago and the supplied init files were mangled so I had to call them in Germany, but Keil have been in the game for a long time and I would try their gear again.

    • Mr Foo says:

      Armpit Scheme might well be worth a look. Scheme on the metal FTW.

      I’m personally working on another Scheme dialect that handles multiprocessing across multiple ARM-M chips, but it’s really gnarly and totally user-unfriendly at the moment – basically everything has to be written in Continuation-Passing-Style, which hurts.

      There’s various Forths out there, as well, but I wouldn’t consider them to be significantly easier than C. I wouldn’t consider BASIC as a desirable language, either, come to that.

      • Christian Black says:

        Thank you Mr Foo. I shall look into that suggestion, though multi-processor jobs are well beyond me. I understand why certain programming languages are deprecated but in practice I have found that my BASCOM BASIC projects work as well as my IAR C projects. (er, they do work!)

    • Mr Foo says:

      Ah, can’t reply to your reply.

      So, anyway, don’t want to get into the “this PL is better than that PL” argument – that goes nowhere, and if your BASIC stuff is working, that’s really all that matters, regardless of what Dijkstra said.

      As far as BASICs go, there’s a few out there. hbbrbasic.com have a compiler which goes for $79, which is about the cheapest one I’ve found specifically supporting STM32/M3.

      I’d strongly suggest a Scheme or Lisp, though. There’s an “interesting” learning curve (i.e. it will blow your mind if you’ve never touched it before) but it will take you places you’ve never been. Simultaneously lower level than C and higher level than most other languages, and spectacularly easy to compile (most implementations of Lisp are written almost or entirely in Lisp, and the “reference” implementations usually include a compiler – see Sussmann’s Scheme book or ‘LiSP in Small Pieces’ for examples).

      My own ARM Scheme compiler is written in / hosted on Extempore, which is a scheme-like language that compiles via LLVM intermediate representation, which is then thrown through LLVM to produce an ARM binary.

      As for IDEs, you’re probably out of luck unless you go with a commercial C/Asm. anything else is probably gonna require something like eclipse or Emacs hooked up to OpenOCD or similar. That’s “fun” to set up.

      • WestfW says:

        Are there still LISPs out there? Most of the LISP hackers I knew have moved on, and I haven’t seen LISP code (other than EMACS macros) for anything in a long time. Are there micro-LISPs with any level of standardization? I dunno if I buy this “my own XXX-like language for YYY” stuff any more; a major reason for using a HLL for me is portability. (of course, I guess that’s sort-of where BASIC is as well.)

      • Christian Black says:

        Thank you. I have had a peek at scheme & lisp, and, yes, there’s some potential for mind-blowing there! I think I will save that for the part of my tech-life where I tinker with exotica like Prolog rather than the part where I try to put code into little microcontroller gadgets. I’m delighted at the answers I’ve had to my query and relieved I didn’t accidentally start a PL flame war.

      • Mr Foo says:

        Are there still lisps out there? Yep, loads. Probably the best known of them is Ruby. It’s stretching the point a little, as it’s got a more imperative feel than lisp/scheme’s functional approach, but there are a lot of parallels – closures and continuations are first class objects, implementing lisp in ruby and vice versa are pretty much no-brainers.

        http://onestepback.org/index.cgi/Tech/Ruby/LispInRuby.red

        http://imagine27.com/articles/2010-10-07-084756_ruby_subset_implementation.html

        The latter implements a subset of Ruby in Common Lisp which is significantly faster than MRI Ruby 1.9 can do using C.

        Metaprogramming in Ruby is harder than in Lisp (you have to write a lot more code, for one), but that’s mainly a syntax exercise as well. There are some differences between what can be done in one vs the other, but the results are largely equivalent.

        Common Lisp is still around, although it’s still the fsck-ugly monolith it aways was, and R6RS has been released (that’s the spec for the latest version of scheme). TinyScheme is used all over the place, and Lua is used a lot as well.

        Perhaps due to Ruby’s success, and the follow-up bits that have hit javascript, elements of lisp are beginning to make headway in more “common” languages; C/ObjC ‘blocks’ as featured in Apple’s runtime (and in the LLVM implementation of the same) are closures in disguise, as are C++0x blocks (which are more configurable, but massively harder to use, than the Apple/LLVM version).

        The main problem people have when they first hit lisp is the brackets. Lots of insane stupid parentheses. But that’s merely syntax, and it’s relatively trivial to make a lisp reader that takes a more conventional syntax. This is close, in fact, to what the Ruby interpreter <v1.9 did, as it converted Ruby syntax to an abstract syntax tree, much like that used in lisp, and then interpreted that. This adds a significant overhead, though, and once you've learned to grok the brackets, it's an overhead you don't need.

        Lisp, like punk, is not dead. It's just calling itself something else for the most part.

      • WestfW says:

        Huh. I used to know a bunch of the people from Lucid. I suppose the main mind-blowing aspect of LISP-like languages is that the program has run-time access to its own symbol tables? I think the only LISP program I’ve ever worked on was a pretty vanilla MacLISP utility that would have worked equally well in any number of other languages.

      • Mr Foo says:

        Metaprogramming, which springs from the “code is data” concept, is pretty good at scaring people, it’s true. You don’t *need* to do it to make lisp work for you, but it can make life much easier and more efficient in many cases (see the “ruby in lisp” post I linked to above for starters). It’s also part of why Lisp, Scheme and friends are so loved in PL research, as it makes it easy to reason about code.

        The latter fact also tends to put “real world” people off lisp, as it’s seen as being “only any good for academia”, where in fact it was and is a systems programming language.

        Anyway, this is all rather offtopic, and I have a real time garbage collector to tune. When you’ve only got 8K to play with…

      • Renato says:

        Anybody knows what happens to Hbbr Basic ?

  12. Chris says:

    Congrats, BarMonster! I like how you brought out I/O pins to oversized solder pads. The ST M3’s are amazing chips too.

    One critique. You should include decoupling caps on every MCU power pin, as close as possible to the MCU. The datasheet will have recommendations. Failure to include them can sometimes lead to erratic behavior, which can be *very* hard to diagnose.

    • BarsMonster says:

      Yes, I’ve seen that datasheed requires that. But this is one more point of critique for ARM’s – ‘need lots of caps’, so I tried to test if it would work without them, and it appeared it does, and there is no noise on the power lines.

      Probably on 1.8V supply and extreme temperatures and load all these caps would be needed, but not in my case.

      • h3llphyre says:

        As a proof of concept, I think what you’ve done is fine. The problem occurs when people try adding additional circuitry to your design and the ARM chip gets flaky, due to noise on the rails from either other components (conducted noise) or from an external source (radiated noise).

        Again, excellent proof of concept to show how simple and cheap ARM can be.

      • fede.tft says:

        You don’t need all that many capacitors as they say in the application notes. As a rule of thumb I use two 100n for 64pin packages and four 100n for 100pin pacakegs, always placed as close as possible to the power supply pins. Never had any trouble.

  13. WestfW says:

    Single-sided isn’t the only thing needed to make a PCB machinable via CNC. The board here has trace spacing (.15 to .3mm) that is pretty much beyond the “easy” level (especially if you need to hand solder with no soldermask), and pretty close to the limits of what is possible (LPKF machines claim 0.2mm normally, or 0.1mm with Very Expensive bits.)

  14. WestfW says:

    Even with no soldermask? In my (rather limtited) experience, a lot of the things that make fine pitch SMT work better than you’d think “go away” if the solder isn’t restricted to the pads by a mask…

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Follow

Get every new post delivered to your Inbox.

Join 92,355 other followers