Developed on Hackaday: Security and Arduino Compatibility

2013-12_Developed_on_Hackaday

Some of our readers noticed that the Hackaday community open-source offline password keeper (aka Mooltipass) has two incompatible characteristics: being secure and Arduino compatible.

Why is that? Arduino compatibility implies including a way to change the device firmware and accessing the microcontroller’s pins to connect shields. Therefore, some ill-intentioned individuals may replace the original firmware with one that would log all user’s inputs and passwords, or in another case simply sniff the uC’s signals. The ‘hackers’ would then later come to extract the recorded data. Consequently, we needed a secure tamper-proof Mooltipass version and an Arduino-compatible one, while allowing the former to become the latter.

Olivier’s design, though completely closed, will have several thinner surfaces directly above the Arduino headers. As a compromise, we therefore thought of sending a bootloader-free assembled version to the people only interested in the password keeper functionality, while sending a non-assembled version (with a pre-burnt bootloader) to the tinkerers. The Arduino enthusiasts would just need to cut the plastic at the strategic places (and perhaps solder headers to save costs). The main advantage of doing so is that the case would be the same for both versions. The drawback is that each board would have a different firmware depending on who it is intended for.

What do our reader think? For more detailed updates on the Mooltipass current status, you can always join the official Google group.

Ask Hackaday: Wiping Your Bum With An Arduino?

TP

Over or under? Standing or sitting? Truly, toilet paper has been the focus of the most irreconcilable arguments ever. The folks on the Arduino Stack Exchange have a far more important question: how do you trigger an alarm when your TP supply is low?

[user706837] asked the Internet this question in response to his kids never replacing an empty roll. This eliminates the most obvious means of notifying someone of an empty roll – looking at it before you sit down – and brings up a few interesting engineering challenges.

Most of the initial ideas deal with weight or some sort of light sensor that can differentiate between the white TP and the brown roll. A much, much more interesting solution puts a radioactive source in the TP holder’s spring-loaded rod and uses a sensor to detect how much TP is left. A quick back-of-the-wolfram calculation suggests this might be possible, and amazingly, not too dangerous.

We’re turning this one over to you, Hackaday readers. How would you design an empty toilet paper alarm? Bonus points awarded for ingenuity and cat resistance.

Image source, and also one of the longest and most absurd Wikipedia articles ever.

A Cocktail Shaker With Android And Arduino

drinks

The most rewarding part of any project must be sitting down to see the fruits of your labors set in action for the first time and relaxing with a nice drink. [Tony DiCola] is really showing off his ability to think ahead, because his smart cocktail shaker takes care of the post-build celebration, measuring out drinks with exacting precision.

The build measures out precise amounts of any liquid with the help of a small electronic scale [Tony] picked up from Harbor Freight. Instead of trying to interface with the electronics in the scale, he instead connected a INA125 instrument amplifier to the load cell. An Arduino micro measures the weight on the load cell, and with the known densities of gin, vermouth, and Kahlua, [Tony] can get a very good idea of how much liquid is in the cocktail shaker.

The really neat part of this build is the interface: [Tony] wrote an Android app for his tablet that talks to the Arduino with an Adafruit Bluefruit Bluetooth adapter. The app receives the current weight on the load cell, displays the current amount of liquor in the cocktail shaker, and provides step-by-step instructions for making any cocktail.

It’s a handy little device to keep around the liquor cabinet, and with an absurd amount of pumps and valves could easily become the basis for a very cool cocktail bot.

[Read more...]

Turning A Router Into An Arduino Yún

yun

The Arduino Yún was the first of a new breed of Arduinos that added a big honkin’ Linux System on Chip to the familiar ATMega microcontroller and unique pin headers. It’s a surprisingly powerful system, but also very simple: basically, it’s just an Atheros AR9331 running Linux, an ATMega32u4 doing its Arduino thing, both connected by a serial connection. The Atheros AR9931 is also found in a router popular amongst hardware hackers. It really was only a matter of time before someone ported the Yun software to a router, then.

[Tony] took a TL-WR703N router and put OpenWRT on it. Turning this router into the Linux side of a Yún was a simple matter of uploading the Yún software to the root directory of the router and rebooting it. The Arduino side of the Yún is handled by an Arduino Mega connected to the USB port of the router. A quick update to Arduino’s boards.txt file, and a hacked together Yún is just a strip of duct tape away.

The Yún may not be extremely popular, but it does have a few interesting use cases. Maybe not enough to drop $70 on a board, but if you already have a WR703 router, this is a great way to experiment.

Thanks [Matt] for the tip.

A Low Cost Arduino FPGA Shield

ardu-fpga

[technolomaniac] is kicking butt over at Hackaday Projects. He’s creating a low cost Arduino based FPGA shield. We’ve seen this pairing before, but never with a bill of materials in the $25 to $30 range. [technolomaniac's] FPGA of choice is a Xilinx Spartan 6. He’s also including SDRAM, as well as an SPI Flash for configuration. Even though the Spartan 6 LX9 is a relatively small FPGA, it can pack enough punch that the Arduino almost becomes a peripheral. The main interconnect between the two will be the Arduino’s ability to program the Spartan via SPI. Thanks to the shared I/O pins though, the sky is the limit for parallel workflow.

[technolomaniac] spent quite a bit of time on his decoupling schematic. Even on a relatively small FPGA power decoupling is a big issue, especially when high speed signals come into play. Thankfully Xilinx provides guides for this task. We have to mention the two excellent videos [technolomaniac] created to explain his design. Documenting a project doesn’t have to be hours of endless writing. Sometimes it’s just easier to run a screen capture utility and click record. As of this writing, the schematic has just been overhauled, and [technolomaniac] is looking for feedback before he enters the all important layout stage. The design is up on his github repository in Altium format. Due to its high cost, Altium isn’t our first pick for Open Hardware designs. There are free viewers available, but [technolomaniac] makes it simple by putting up his schematic in PDF format (PDF link). Why not head over to projects and help him out?

[Read more...]

Gamebuino: A Handheld Arduino Gaming Console Ready for Prime Time

Gamebuino

[Rodot] wrote in to tell us about the Gamebuino, a very nicely designed and easily reproducible version of his handheld Arduino gaming console. We originally featured [Rodot's] Arduino based gaming console over a year ago.

With the Gamebuino, you too can build your own games and gaming hardware around the Arduino. While there is a lot of information currently missing from the site’s Wiki, such as the layout and game code, [Rodot] plans on making everything open source. The console includes a rechargeable lithium battery, a micro SD card, and I2C expansion connectors. This is one project to keep an eye (and two hands) on, especially since a full game library is going to be provided, letting you easily create your own games. See what the console can do in the demo video after the break.

It would be amazing so see some old Game Boy games ported to run on the Arduino, or maybe one of our readers can make an Game Boy emulator for the Arduino!
[Read more...]

An Arduino Programmable Load

load

Having a big block of hot to dump current into is a very useful thing to have if you’re testing batteries, power supplies, high power LEDs, electroplating, or any thing else that would normally require a huge resistor. [Jakub] found himself in need of an electronic load, and instead of a transistor and a pot, decided to make something more automatic: a programmable load built around an Arduino shield.

The idea behind this load is pretty simple: connect a device to a FET and shunt resistor to measure current. Drive the gate of the FET with an op-amp that maintains either constant current or constant voltage. Control everything with a DAC, and you have a programmable load controlled by an Arduino.

With such a small form factor, getting rid of all that heat was bound to be a problem. For this, [Jakub] is using a 50×50 mm BGA style heat sink with a 5V fan. If it’s good enough for a big CPU, it should be able to handle dumping 70 Watts into a FET. There’s also a conservative application of thermal paste and a very small thermistor underneath the FET that’s able to be read by the Arduino. It might slowly heat up your room, but it’s not going to catch fire.

With the Arduino sketches [Jakub] wrote for his load he was able to characterize a pair of Idea batteries and figure out how much charge a three-year-old recyclable battery had. It’s a great piece of work, and if [Jakub] is willing to go through the hassle of a Kickstarter, it would make a fine crowdfunded product.