Hardware prototyping

Here are my solutions for prototyping with NXP Cortex M3 uC…

The hard way

This is the cheapest way, but not the easiest nor the quickest.

The idea is to buy the raw components and to use a Schmartboard  QFP adapter board (32-100 pins, 0.5mm pitch) to solder the ARM cortex M3 uC without requiring SMD soldering skills.

Here is the schematic and the resulting prototype :

In France, the LPC1756 uC costs 6 euro and the Schmartboard adapter 10 euro, so this is quite a cheap prototyping solution.

But it will take a lot of time to solder and double-check every pin…

When I started this, no prototyping board was available, excerpt for those costing more than a few hundreds of dollars.

But recently, some “affordable” prototyping board have appeared…

Olimex 1766 STK

This board has everything I need for my projects and the price makes it “affordable” for me (about 100 euro) :

I’ve just received mine, and I will test it ASAP…

NGX Blueboard

This one is much more limited in terms of features, but its price makes it the cheapest target board currently available : $33.

There may and will be other solutions, but those one give a good view of what can be done…

Well, now that we have a prototyping board, the next step will be to setup the tools needed for programming and debugging… (coming soon!)

adapter board

10 Responses to “Hardware prototyping”

  1. John Harris says:

    The NGXBluebird uses the LPC1768 which is my Cortex-M3 of choice, because of the encoder inputs and built-in position and velocity counters. Reviewing your C_template project, only the two linker files seem to specifically relate to the LPC1756 everything else is LPC17xx. So to make a new project for the NGXBluebird, do I just make a copy of C_template, change the name, and edit the two linker files?

  2. John Harris says:

    PS my NGXBlueBird is on order, as of this morning. Thanks for the link

  3. nio says:

    Yes, you’ll just have to edit the linker scripts to reflect the LPC1768 memory mapping… have fun!

  4. robert says:

    take an mbed (mbed.org) plus a breadboard and you get something easy to use. the c++ stuff inside the mbed is so easy to use. makes embedded programming a snap.

  5. nio says:

    Yes, you’re right, the real advantage of the mbed is that it’s really easy to use and when programming, you’re staying at a high level API, so the learning curve is very interesting.
    It could be seen as some kind of ARM Cortex “Arduino” ?

    The main disadvantages -for me- are :
    1) no debugger & high level API programming only
    2) online compiler (I don’t like the idea, but it’s less important)

    If at some time in your project you want to mess with some low-level feature, and need some breakpoint to check something in your code, mbed is not for you.

  6. robert says:

    the main ‘issue’ is that the mbed api is not opensource. when it would be opensource then i will directly start a port using gcc.
    another point would be a c++ thing of freertos. too much ram without a real os is some sort of pain to me.

  7. John Harris says:

    My BlueBird-1768 was ordered on the 15th. I got notice that it shipped on the 26th, and a tracking link showing that it was in Madras on the 27th. Slow, but perhaps they are just getting started.

  8. John Harris says:

    My Blueboard-1768 arrived today, registered mail 14 days after my order. Not bad from India to USA. The tracking system does not seem to be up to the task.
    The board looks good so I will start testing.

  9. John Harris says:

    Programming the Blueboard. I used a USB to UART bridge from http://www.customidea.com . I connect TX (P8) on the bridge to RXD0 (J3-2) on the Blueboard, RX (P7) to TXD ( J3-1) and GND (P1) to GND (J3 -6). After installing the two drivers from CustomIdea I now have a VCP connection to my PC. Flash Magic (free) allows me to download hex files using the LPC1768 bootloader. Hold down SW2 (ISP) and press and release SW1 (RST) and you are in the download mode.

  10. Riccardo Manfrin says:

    Hope it can be handy:
    TARGET=arm-elf # Or: arm-none-eabi arm-linux … what’s the difference?
    PREFIX=/usr/local/arm-elf/ # Install location of your final toolchain




    BINUTILSCONFOPTIONS=”–enable-interwork –enable-multilib –with-gnu-as –with-gnu-ld –disable-nls”
    GCCBOOTCONFOPTIONS=”–enable-interwork –with-system-zlib –enable-multilib –with-newlib –without-libc –without-headers –disable-nls –disable-libssp –disable-shared –enable-languages=c –with-gnu-as –with-gnu-ld –with-float=soft”
    NEWLIBCONFOPTIONS=”–enable-interwork –enable-multilib –with-gnu-as –with-gnu-ld –with-float=soft”
    GCCREALCONFOPTIONS=”–enable-interwork –with-system-zlib –enable-multilib –with-newlib –without-libc –with-headers=../$NEWLIB/newlib/libc/include –disable-nls –disable-libssp –disable-shared –enable-languages=c,c++ –with-gnu-as –with-gnu-ld –with-float=soft”
    GDBCONFOPTIONS=”–enable-interwork –enable-multilib –with-gnu-as –with-gnu-ld”

    #–with-newlib : for arm-elf we use this lib as we don’t run the output binaries on linux (uClibc, glibc) but on arm straight.
    #–without-headers : we don’t relay on a linux kernel
    #–disable-libssp : gcc fails to compiler with stack smash protection
    #–disable-nls : we don’t want output in other languages than American English
    #–with-system-zlib : avoid to use gcc included zlib sources which cannot be checked during gcc bootstrap run as linking is not available yet (linker is environment dependent and can be generated only after newlib @ gcc second run.
    #–enable-interwork :allows arm/thumb code mixing when compiling
    #–enable-multilib :needed to support arm,thumb and thumb2 code at the same time

    #// build.sh

    source setup.cfg

    export PATH=”$PREFIX/bin:$PATH”
    if [ ! -e $BUILD ]; then
    mkdir $BUILD
    if [ ! -e $PROGRESS ]
    echo “0″ > $PROGRESS

    STEP=$(cat $PROGRESS)
    if [ $STEP == 0 ]; then
    echo “*** “$BINUTILS” building stage…”
    echo “PRESS ENTER…”
    if [ "x$BINUTILSCVS" = "xy" -o "x$BINUTILSCVS" = "xY" -o "x$BINUTILSCVS" = "x" ]; then
    rm -rf $BINUTILS ./build/* patch*
    if [ ! -e $BINUTILS.tar.bz2 ]; then
    wget -c $BINUTILSITE$BINUTILS.tar.bz2
    tar xfvj $BINUTILS.tar.bz2
    if [ "x$BINUTILSCVS" != "xy" -a "x$BINUTILSCVS" != "xY" -a "x$BINUTILSCVS" != "x" ]; then
    if [ ! -e $BINUTILSPATCH.gz ]; then
    if [ ! -e $BINUTILSPATCH ]; then
    gunzip $BINUTILSPATCH.gz
    patch -p0 -strip0 $PROGRESS

    STEP=$(cat $PROGRESS)
    if [ $STEP == 1 ]; then
    echo “*** “$GCC” building 1st stage…”
    echo “PRESS ENTER…”
    if [ ! -e $GCC.tar.bz2 ]; then
    wget -c $GCCSITE$GCC.tar.bz2
    if [ ! -e $GCC ]; then
    tar xfj $GCC.tar.bz2
    rm -rf build/*
    cd build
    ../$GCC/configure –target=$TARGET –prefix=$PREFIX $GCCBOOTCONFOPTIONS
    make all-gcc install-gcc
    cd ..
    echo “2″ > $PROGRESS

    STEP=$(cat $PROGRESS)
    if [ $STEP == 2 ]; then
    echo “*** “$NEWLIB” building stage…”
    echo “PRESS ENTER…”
    if [ ! -e $NEWLIB.tar.gz ]; then
    wget -c $NEWLIBSITE$NEWLIB.tar.gz
    if [ ! -e $NEWLIB ]; then
    tar -xzf $NEWLIB.tar.gz
    rm -rf build/*
    cd build
    ../$NEWLIB/configure –target=$TARGET –prefix=$PREFIX $NEWLIBCONFOPTIONS
    make install
    cd ..
    echo “3″ > $PROGRESS

    STEP=$(cat $PROGRESS)
    if [ $STEP == 3 ]; then
    echo “*** “$GCC” building 2nd stage…”
    echo “PRESS ENTER…”
    rm -rf build/*
    cd build
    ../$GCC/configure –target=$TARGET –prefix=$PREFIX $GCCREALCONFOPTIONS
    make all install
    cd ..
    echo “4″ > $PROGRESS

    STEP=$(cat $PROGRESS)
    if [ $STEP == 4 ]; then
    echo “*** “$GDB” building stage…”
    echo “PRESS ENTER…”
    if [ ! -e $GDB.tar.gz ]; then
    wget -c $GDBSITE$GDB.tar.gz
    if [ ! -e $GDB ]; then
    tar xzf $GDB.tar.gz
    rm -rf build/*
    cd build
    ../$GDB/configure –target=$TARGET –prefix=$PREFIX $GDBCONFOPTIONS
    make install
    cd ..
    echo “5″ > $PROGRESS

Place your comment

Please fill your data and comment below.
Your comment