Arduino Vs. Phidgets Vs. Gadgeteer

January 12, 2015 by 36 Comments

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:

Continue reading “Arduino Vs. Phidgets Vs. Gadgeteer” →

Arduino Vs. Phidgets – Dev Time Trials

January 4, 2015 by 38 Comments

Is developing on an Arduino too slow? Are Phidgets too expensive? When might you use one or the other? Hackaday regular [Ken] breaks down what he learned from three experimental time trials.

The main development differences between Arduino and Phidgets are a mix of flavor preferences and some hard facts. The Arduino is open source, Phidgets are proprietary. Arduino requires a mix of hard- and software where Phidgets only needs (and only allows) a connection to a full computer but enables high level languages – it is expected to get the job done sooner and easier. And finally, Arduinos are cheap, Phidgets are 3-5x the cost.

The three time trials were common tasks: 1. Blink an LED. 2. Use a pot to turn a servo. 3. Build a pedometer. For [Ken], the Phidgets won in each of the three experiments, but not significantly: 37%, 45%, and 25% respectively. The difference is only minutes. Even considering time value, for most hackers it is not worth the cost.

HAD - Phidgets3In context, the advantages of a mildly more rapid development on the simplest projects are wasted away by needing to rebuild a permanent solution. Chained to a PC, Phidgets are only useful for temporary or fixed projects. For many of our readers that puts them dead in the water. Arduinos may technically be dev kits but are cheap enough to be disposed of in the project as the permanent solution – probably the norm for most of us.

[Ken] points out that for the software crowd that abhor electronics, Phidgets plays to their preferences. Phidgets clips together their pricey peripherals and the rest is all done in code using familiar modern languages and libraries. We wonder just how large this group could still be; Phidgets might have been an interesting kit years ago when the gulf between disciplines was broader but the trend these days is towards everyone knowing a little about everything. Hackaday readers probably represent that trend more than most, but let us know if that seems off.

[Ken]’s article has much more and much better detailed explanations of the experiments and the tradeoffs between the platforms.

If you enjoy watching parallel engineering, see the time-lapse video below for a split screen of the time trials.

Continue reading “Arduino Vs. Phidgets – Dev Time Trials” →

Lo-Fi Tchaikovsky

February 22, 2023 by 4 Comments

[Kevin] over at Simple DIY ElectroMusic Projects recently upgraded his Lo-Fi Orchestra. To celebrate his 400th blog post, he programmed it to play Tchaikovsky’s 1812 Overture. Two Arduino Nanos, four Arduino Unos, four Raspberry Pi Picos, and one Raspberry Pi have joined the Lo-Fi Orchestra this year, conducted by a new Pico MIDI Splitter. Changes were made in every section of the orchestra except percussion. We are delighted that the Pringles tom and plastic tub bass drums remain, not to mention the usual assortment of cheap mixers, amps, and speakers.

Tchaikovsky’s score famously calls for some “instruments” not found in the typical orchestra — a battery of cannon and a carillon, for example. Therefore [Kevin] had to supplement the Lo-Fi Orchestra for this performance with extras — a JQ6500 MP3 module on clash cymbals, a bare metal MiniDexed Raspberry Pi playing the carillon, and a MCP4725 with a Lots-of-LEDs shield firing off cannon and fireworks, respectively.

Although slightly disappointed that the MCP4725 beat out Mr. Fireworks in the auditions, we do like the result. [Kevin] reports that the latest version is much more reliable and predictable, having eliminated various MIDI faults and electrical noise. It presents a stable platform for future musical presentations, a kind of on-demand Lo-Fi Orchestra jukebox, as he describes it. A detailed review of all the changes can be found in his explanatory blog post. Check out an earlier performance of Holst’s The Planets suite from our coverage back in 2021.

Continue reading “Lo-Fi Tchaikovsky” →

The J1772 Hydra Helps You Charge Two EVs At Once

December 2, 2022 by 20 Comments

There are plenty of electric vehicle (EV) chargers out there that are underutilized. This is particularly common where older EVs are involved, where the cars may only be able to charge at a few kW despite the charger being capable of delivering more. [Nick Sayer] regularly found 6.6 kW chargers being used by vehicles that could only draw down 3.3 kW at his work. Thus, he built the J1772 Hydra as a nifty double-adapter to charge two cars at once.

The Hydra comes in two versions. One is a “splitter,” which is designed to be plugged into an existing J1772 AC charger. The other is a version designed for permanent installation to an AC power supply as an EV charger in its own right. Either way, both versions of the Hydra work the same way. In “shared” mode, the Hydra splits the available AC power equally between both cars connected to the charger. When one completes, the other gets full power. Alternatively, it can be set up in “sequential” mode, allowing one car to first charge, then the other. This is great when you have two cars to charge overnight and don’t want to wake up to shift the plugs around.

It’s a neat hack that could be useful if you’re running older EVs that rely on slower AC charging. We’ve seen other DIY EV chargers before, too. Expect hacking in these areas to become more commonplace as EVs grow in popularity.

DIY Arduino Based EV Charger Saves Money, Looks Pro

April 28, 2022 by 56 Comments

Electric vehicles (EVs) are something of a hot topic, and most of the hacks we’ve featured regarding them center on conversions from Internal Combustion to Electric. These are all fine, and we hope to see plenty more of them in the future. There’s another aspect that doesn’t get covered as often: How to charge electric vehicles- especially commercially produced EV’s rather than the DIY kind. This is the kind of project that [fotherby] has taken on: A 7.2 kW EV charger for his Kia.

Faced with spending £900 (about $1100 USD) for a commercial unit installed by a qualified electrician, [fotherby] decided to do some research. The project wasn’t outside his scope, and he gave himself a head start by finding a commercial enclosure and cable that was originally just a showroom unit with no innards.

An Arduino Pro Mini provides the brains for the charger, and the source code and all the needed information to build your own like charger is on GitHub. What’s outstanding about the guide though is the deep dive into how these chargers work, and how straightforward they really are without being simplistic.

Dealing with mains power and the installation of such a serious piece of kit means that there are inherent risks for the DIYer, and [fotherby] addresses these admirably by including a ground fault detection circuit. The result is that if there is a ground fault of any kind, it will shut down the entire circuit at speeds and levels that are below the threshold that can harm humans. [fotherby] backs this up by testing the circuit thoroughly and documenting the results, showing that the charger meets commercial standards. Still, this isn’t a first-time project for the EV enthusiast, so we feel compelled to say “Don’t Try This At Home” even though that’s exactly what’s on display.

In the end, several hundred quid were saved, and the DIY charger does the job just as well as the commercial unit. A great hack indeed! And while these aren’t common, we did cover another Open Source EV charger about a year ago that you might like to check out as well.

Continue reading “DIY Arduino Based EV Charger Saves Money, Looks Pro” →

Running 57 Threads At Once On The Arduino Uno

March 17, 2021 by 44 Comments

When one thinks of the Arduino Uno, one thinks of a capable 8-bit microcontroller platform that nonetheless doesn’t set the world alight with its performance. Unlike more modern parts like the ESP32, it has just a single core and no real multitasking abilities. But what if one wanted to run many threads on an Uno all at once? [Adam] whipped up some code to do just that.

Threads are useful for when you have multiple jobs that need to be done at the same time without interfering with each other. The magic of [Adam]’s ThreadHandler library is that it’s designed to run many threads and do so in real time, with priority management as well. On the Arduino Uno, certainly no speed demon, it can run up to 57 threads concurrently at 6ms intervals with a minumum timing error of 556 µs and a maximum of 952 µs. With a more reasonable number of 7 threads, the minimum error drops to just 120 µs.  Each thread comes with an estimated overhead of 1.3% CPU load and 26 bytes of RAM usage.

While we struggle to think of what we could do with more than a handful of threads on an Arduino Uno, we’re sure you might have some ideas – sound off in the comments. ThreadHandler is available for your perusal here, and runs on SAMD21 boards as well as any AVR-based boards that are compatible with TimerOne. We’ve seen other work in the same space before, such as ChibiOS for the Arduino platform. Video after the break.

Continue reading “Running 57 Threads At Once On The Arduino Uno” →

Blue Pill Vs Black Pill: Transitioning From STM32F103 To STM32F411

January 20, 2021 by 78 Comments

For many years now, the so-called ‘Blue Pill’ STM32 MCU development board has been a staple in the hobbyist community. Finding its origins as an apparent Maple Mini clone, the diminutive board is easily to use in breadboard projects thanks to its dual rows of 0.1″ pin sockets. Best of all, it only costs a few bucks, even if you can only really buy it via sellers on AliExpress and EBay.

Starting last year, boards with a black soldermask and an STM32F4 Access (entry-level) series MCUs including the F401 and F411 began to appear. These boards with the nickname ‘Black Pill’ or ‘Black Pill 2’. F103 boards also existed with black soldermask for a while, so it’s confusing. The F4xx Black Pills are available via the same sources as the F103-based Blue Pill ones, for a similar price, but feature an MCU that’s considerably newer and more powerful. This raises the question of whether it makes sense at this point to switch to these new boards.

Our answer is yes, but it’s not entirely clearcut. The newer hardware is better for most purposes, really lacking only the F103’s dual ADCs. But hardware isn’t the only consideration; depending on one’s preferred framework, support may be lacking or incomplete. So let’s take a look at what it takes to switch. Continue reading “Blue Pill Vs Black Pill: Transitioning From STM32F103 To STM32F411” →