Arduino vs. Phidgets vs. Gadgeteer

A few days ago, we saw a dev time trial between the Arduino and Phidgets, a somewhat proprietary dev board that is many times more expensive than an Arduino. The time trial was a simple experiment to see which platform was faster to prototype simple circuits. As always in Hackaday comments, there was a ton of comments questioning the validity and bias of the test. Not wanting to let a good controversy go to waste, [Ian Lee] tossed his hat into the ring with the same dev trial with the Gadgeteer.

The Gadgeteer has the same design philosophy as Phidgets: modular components and a unique software system -the Gadgeteer is based on .NET Micro Framework – that allows you to get up and running quickly. Unlike Phidgets, the Gadgeteer is priced competitively with the Arduino, and the mainboard is priced within an order of magnitude of a single ATMega chip.

[Ian] pulled off three projects with the three development platforms: blinking a LED, moving a servo, and building a pedometer with an accelerometer. For each trial, the time taken and the price of all components were added up. Here’s the relevant graph:

TestsOverviewChart

According to the tests, the Gadgeteer won by a large margin. We’re not going to call this a definitive test, and no sane person should think it is. It does, however, highlight the benefits of a well-designed ‘module-based’ development system combined with a good IDE: the Gadgeteer is consistently faster than Phidgets, and just a bit more expensive than an Arduino.

While a time trial consisting of one developer writing code to blink a LED, move a servo, and read a pedometer is hardly enough to make any conclusions, it does demonstrate that the Gadgeteer isn’t that much more expensive than using an Arduino. We’ll leave the rest of the discussion to the commentors below.

36 thoughts on “Arduino vs. Phidgets vs. Gadgeteer

  1. “We’re not going to call this a definitive test”: It IS a definitive test!!

    “and no sane person should think it is”: They call me crazy! I’ll show them – I’ll show them all!! Bwa-ha-ha-ha-haaaaa!

  2. Arduino’s library is 9000X bigger than the others. Giving it an absolute edge. that is the biggest hurdle any new system will have, you can not get around the fact that there is a metric ton of libraries to make anything brain dead easy on a duino.

    MSP430 is a failure because of this (TI’s libraries are bare and written by insane people) Just look at the insanity that is the TI watch example programs and libraries.

    1. TI’s old stuff was definitely ill supported, and while it is still no match for the Arduino’s community support, TI’s products (especially the MSP430 line) have received a huge dose of well documented examples projects, protocol stacks and function libraries that make modern TI products very easy to develop on now.

    2. I started out on the MSP430 line so I’m a little biased in this argument.

      The MSP430 line by default is developed for using C/C++ and I like having that option. I feel it gives me more control over the MCU I am using. Not to mention TI’s GRACE makes initial buffer configuration dead simple.

      Energia is also a community driven, Arduino-like IDE that allows the MSP430 line to use a lot of Arduino code examples and libraries. Makes development just as easy.

      I think MSP430 is a more appropriate option for smaller and less-CPU/power intensive projects, plus a lot of the entry level chips are removable from the dev board and can go right in complete circuits.

      I’ve had only limited experience with the Arduino platform and I find it to be almost identical to Energia development so far. I do like it though, feels a bit more user friendly and has a smaller learning curve.

      1. I like Phidgets (and now the Raspberry Pi) because it allows a project to be written fully in Python, the Arduino does not allow this. I usually stay away from C / C++ because Python gives me a much better return of time invested/result in a project.

        1. Zerynth (formerly Viper) embedded Python is quite nice. Flashes nicely to ARM Cortex boards, including Arduino Due. I personally am messing around with it on a Photon.

  3. Tons of libraries for Arduino and similar boards, true. I own a SparkFun Redboard, two Pololu A* micros, and an Adafruit Trinket. Also have mbed-based boards (mBuino, RETRO, etc.), and an Espruino (with a Pico on the way). And I like working with all of those. I especially like the fact that there are plenty of libraries for running WS2811/12 blinkies, which are some of my favorite things.

    But when something’s not working right, I’d much rather set a breakpoint in my code and step through line-by-line than have to spit stuff out to the serial monitor. That’s when Gadgeteer really shines, IMO. Don’t need a JTAG, don’t have to spend extra money on anything for debugging. Visual Studio Express is all that’s needed.

    1. Thoroughly agree. I’ve gone from being a Microsoft naysayer to loving Visual Studio. Debugging .NET code is so much easier than debugging most other stuff. The thought of programming in C# is quite attractive too.

      (I’ll stick to my Arduinos for now, though, cuz I’m a cheapskate and I want to learn C++.)

      1. I think folks should use what they’re comfortable with…AND keep their eyes open for new platforms that may prove useful. Sounds like you’re doing both, good on you.

        And just realized that my comment below in the thread is a partial duplicate of the comment above…apologies for the duplication. It appeared that the first comment didn’t go through properly. My bad.

      2. You don’t need to lay out a lot of money to get decent debugging with breakpoints, single-stepping, etc. Using bare chips with programmer/debuggers (e.g. Microchip PICs with PICkit 3, STM32s with ST-Link, AVRs and any ARM chip with OpenOCD) gives you that along with C++ programming for the 32 bit chips. The programmer/debuggers are a one-time cost of $30-$50, and the microcontrollers are dirt cheap – typically $5 or less. (Microchip has a generous free sample program that could mean you never have to pay for a microcontroller again.)

    1. Gadgeteer is also open. Source code for the base .NET Microframework is open, and the code for most Gadgeteer boards and modules is also available. Many boards and modules also publish the hardware files, so folks can modify and create their own derivatives.

  4. Is it only me or all this pressure to shave some minutes of development time seems… a waste of time? I would agree if with one dev board a developer can do in a day what needs a week with the other one, but minutes, seriously?

    1. I think it’s about making something work as fast as possible to make more time for perfecting/debuging stuff. It woul;d be nice if this comparsion had more ambitious projects as a benchmark (arduinos greatest strength is the amount of libraries it’s very rare for me to code the way i used to umplementing whole communication with module by reading datasheet)

      1. The problem with doing something more ambitious is that then the primary time hurdle is typically in the head of the designer, not in the platform selected.

        So once you figure out how to arrange components, and the logical framework of the code, each future version of the same essential application will be considerably faster.

        I suppose you could try to benchmark these 3 against one another by doing the more ambitious project on a FOURTH platform, then doing it on all three of these ones “after the fact” to get a better comparison. But then someone will come along wanting that fourth one incorporated as well….

    2. There is also the question of how good the code will be if you write it as fast as you can. A bigger platform may make it easier to build a good design without worrying about some small extra overhead. For many embedded projects code reuse and ability to adapt is much more important than shaving off some development time.

    3. I started with .NET Gadgeteer, and have since worked with several Arduino clones (SparkFun Redboard, Adafruit Trinket, and Pololu A* Micro, to name a few), as well as with mbed-based boards and even Espruino (which I really like). Here are the reasons that I come back to Gadgeteer when I start a new project:

      – C# code, in a familiar environment. Visual Studio is my tool of choice, and has been for years. Sometimes, the simplicity of the Arduino IDE is a nice break, but for debugging, I’ll take breakpoints and stepping through my code any day over blinking LEDs and spitting out strings to the serial monitor.
      – Modular design promotes re-use. With Gadgeteer modules, I can build a prototype fast, and just as quickly pull it back apart and reuse the parts in another project. And each module comes with a driver that (much like Arduino libraries) means I have less code to write. While you can get re-use when breadboarding, not so much with perfboard circuits.
      – Faster processors, more Flash and RAM. The lower-end FEZ Cerberus family boards have more Flash and RAM than even the Arduino MEGA, and a faster Cortex M4 processor (168Mhz) than the Arduino DUE. Some of this, it’s important to note, is necessary because NETMF is a managed environment, but I spend less time worrying about whether my code will fit or I’ll run out of memory in a Gadgeteer project (I’ve had more issues with this on mbed devices than on Arduino).

      For folks being negative about this post…what’s the big deal? There’s plenty of room for different platforms, and it’s not like Arduino is going anywhere. It’s a great platform, particularly for hobbyists. But it never hurts to know more ways to solve a given problem, and I’d argue that NETMF and Gadgeteer have some things to offer that don’t exist elsewhere, and it doesn’t cost much to try them out and see.

  5. Someone do that test for micropython and the pyboard.

    blink.py 1min
    import pyb

    while True:
    pyb.LED(1).toggle()
    pyb.delay(100)

    servo.py – 1min
    import pyb

    servo = pyb.Servo(1)
    sw = pyb.Switch()

    while True:
    if switch is True:
    servo(90):
    else:
    servo(0)

    pedometer.py – 6min
    import pyb

    accel = pyb.Accel()
    thresh = 100 # not tested
    count = 0

    while True:
    x,y,z = accel.filtered_xyz()
    if (x**2 + y**2 + z**2)*0.5 > thresh:
    count = count + 1
    with open(‘log.txt’, ‘a’) as logfile:
    logfile.write({}{}/n.format(count, pyb.millis/1000))

    Note, that the only thing you have to do on the hardware side is to connect a servo for servo.py. The pyboard has the fitting 3 pins header.
    Cost?
    pyboard – 42.52$
    servo – 5$
    (microSD card – 10$ > not really needed tough)

    Everything else is already on the pyboard.

  6. il stick to arduino, the libraries are straightforward and fast enough fo 90% of my projects, when its not, i will drop down to the bare metal. its also cheap because of the loads of knockoffs from china.

  7. Personally, I dislike the taint of Micro$oft dot anythings. I don’t use any M$ development tools- I like open source and prefer to work things out on my own, vs. using some megalithic bloatware that makes fast little systems seem like there’s an old 1st generation PC POC under the hood.

    1. I find most commercial software is much more feature-rich than the comparable open source software. I’ve used Eclipse, GCC, GDB, and various plug-ins, and I’ve concluded that they pale in comparison to Visual Studio – despite the fact that I am mildly anti-Microsoft on principle. I’ve cobbled together development environments for ARM and found that they are clumsier and lacking in features (like code generating wizards) compared to integrated packages from microcontroller manufacturers.

      To be sure, there are exceptions (e.g. Firefox vs. IE). But development environments ain’t one of ’em.

  8. One thing that can be said about Phidgets is that they rule in this two categories:
    1. They allow you to work with sensors and electronics, without having to fiddle with breadboards and components like resistors. For a software oriented person that does not have electronics training it is perfect, even when working with analog sensors.
    2. Phidgets, unlike the other two allow you to program the devices in ANY POSSIBLY CONCEIVABLE programming language that exists under the sun, they put a lot of attention and work on that.

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