[Scott] wrote in to share a project he is currently working on, a home automation system that relies on Power over Ethernet. While he’s not completely finished, he’s made some great progress, and the work he has done so far definitely piqued our interest.

Part of [Scott’s] design relies on some reverse engineered Blackberry screens we showed you a while back. He has constructed a small control panel for his apartment, which incorporates one of the aforementioned Blackberry screens, along with 10 tactile switches and a PIR sensor. The panel is built to be mounted in a wall or as a standalone unit, allowing him to control various lights and appliances throughout his home.

[Scott] spent a lot of time working on the communications protocol and UI for his control panel. As it sits now, the panel takes advantage of a VNC-like protocol he designed, which allows him to interact with a Java application residing on his desktop computer.

Things are looking awesome so far, and [Scott] already has a handful of improvements planned for the near future. We can’t wait to check it out when it’s finished.

A commercial potentiostat can cost several thousand dollars, but the CheapStat is an open source project that makes it possible to build your own at a tiny fraction of that cost. It is possible to build one for less than $80, breaking down the cost barrier faced by many labs that would like to have this test hardware.

A potentiostat is used to measure electrochemical properties. To give you a few examples of what it can do, the hardware can measure arsenic levels in water, Vitamin C concentration in orange juice, Acetaminophen concentrations in over-the-counter medications, and a bunch of other less easily explained tests having to do with chemical compounds and DNA.

The device makes use of an Atmel XMEGA microcontroller and connects to a computer via USB. A Java program grabs that data from the hardware displaying test results on your choice of computer platforms. If you’re looking for all the gory details you won’t be disappointed by their journal paper.

[Paul] wrote in to tell us about some interesting Arduino latency issues he helped nail down and fix on the Arduino.

It seems that [Michu] was having some problems with controlling his Rainbowduino project we featured earlier this year, and he couldn’t quite figure out why he was experiencing such huge delays when sending and receiving data.

Searching online for answers turned up very little, and since [Michu] was using Processing, the pair designed a set of tests to see what kind of latency was being introduced by Java. Pitting an Arduino Uno and an Arduino from 2009 against a Teensy 2.0, the tests gauged the latency of native data transfers versus transfers facilitated by Java via the rxtx library it uses for serial communications.

The results were pretty stunning. While both of the Arduinos lagged behind the Teensy by a long shot, their latency values under Java were always 20ms at a minimum – something didn’t add up. [Michu] poked around in the rxtx code and found a mystery 20ms delay programmed into the serial library. It made no sense to him, so he changed the delay to 2ms and saw a drastic increase in performance when transferring less than 128 bytes of data.

The pair’s fix doesn’t seem to affect latency when larger amounts of data (>1kB) are being transferred, but it makes a world of difference when manipulating smaller chunks of data.

For the sake of disclosure, it should be noted that [Paul’s] company produces the Teensy mcu.

[Simon] improved upon an existing hack by making this Arduino ambient lighting system that has four different color regions. He was inspired by [Roy's] processing-based setup which we saw a few weeks ago. That system used processing to determine the average color of the currently displayed image, then it displayed the color on a single RGB LED strip. [Simon] was thinking a little bit bigger.

He purchased a lighting strip that could be cut into different sections and then set out to develop his own software for multiple color regions. He had little or no experience with Processing so he went one abstraction layer lower and used Java to code his interface. It’s got a lot of nice settings where you can tweak how, when, and why colors are displayed. In the end he has four independently addressable color strip on the left, right, top-left, and top-right of the screen. The best part is that the Java suite he developed can be used on different platforms, having been already tested on Windows and Linux.

Interfacing your own hardware with a Java app couldn’t be easier than this example. [Pn] created this proof-of-concept using an Arduino, an analog joystick from a gaming controller, and a few lines of Java code. The Arduino reads an ADC value from the joystick’s x-axis and transmits it over the serial connection ten times a second. The Java program triggers on every serial event, parsing the data based on the @ symbol that the Arduino sends as a start and end condition.

We like this kind of example because there’s nothing extra involved. It lets you take the concept and run with it in any project imaginable. Be it a more complicated Joystick, or simple sensors that you’d like to interface with.

[Rafael] built a system that uses radio frequency for communications. The code he was using with the inexpensive receiver/transmitter pairs already had some error correction but from time to time an entire message would be missed by the receiver. He set out to make these RF communications more robust.

A little more than a year ago we looked at using these same transmitters with an Arduino. [Rafael] has a similar setup but since they are unidirectional he chose to use two pairs for bidirectional communication (each operating at a different frequency to avoid interference). On one end, a computer transmits data to the Arduino which is in a remote location. His confirmation protocol relies on a randomly generated message identifier. The computer will continually transmit the same message. The Arduino continually receives these messages, comparing them with the last successfully received message. If they match, it is considered a successful data transfer and the Arduino transmits a confirmation back to the computer which then starts transmitting the next message.

This isn’t an application-specific protocol. For demonstration purposes [Rafael] built a quick home automation setup that uses it to operate a house lamp.

Here’s a 2-channel Oscilloscope for your Android phone. It uses a base module driven by a dsPIC for signal processing. From there, an LMX9838 Bluetooth module broadcasts the data to the phone so that the waveform can be displayed. [Yus] ported some Python code he had been using over to a set of Java and XML files in order to get it working on Android. This was actually the first time he worked with the SDK… we’d say he’s a quick learner. See it in action after the break.

[Thanks Gabriel]

Thanks to [Josh, Kyle, and Mike], it is now possible to wage (Nerf) war with an Arduino. The turret designed around it is capable of shooting 6 foam projectiles in close succession, between reloads. The faux weapon interfaces with a computer through the Arduino’s onboard serial link (via USB). Software on the PC sends commands to the Arduino, which then executes functions, such as panning, tilting, firing, and rotating the cylinder. The power for the firing itself comes from a 5 gal, 80 psi air compressor. The Java software on the host PC also does smarter things, like show streaming video from the turret’s webcam and even performs basic object tracking (with mixed success). All the code for building the brute is available on [Josh's] website.

[Vlad-Andre] used some of his free time to build an alti-variometer. He does some para-gliding near restricted air space and wanted a backup altitude warning that would help keep him below the mandated altitude. His solution uses the SparkFun Weather Board in conjunction with their BlueSMiRF dongle to measure altitude and transmit it via Bluetooth. From there, he wrote a program to grab the transmitted data with his cell phone and display the information. His application also has the ability to set altitude warnings and log changes over time.

Using this system he is able to get altitude data with 3.5 inch accuracy. Because the capture application is written in Java it should be easy enough to make this work on other cell phone models. The project is clean and works well but we estimate the cost of the parts to be between $250-300, making it out of reach for those who don’t have a specific need for these types of measurements. This is especially true for paragliders who have much less expensive options available to them.
[Thanks Carl-Emil]

[Matthias] from Intuity Media Lab put together a nice bit on controlling office lights with XMPP from his Android phone. In the article, he explains the components involved in the project, why he chose XMPP, and lists everything you need to replicate it. The project makes use of a wide variety of tools and libraries, weaving together code from multiple languages to achieve its goal. Overall, his project is a welcome change in a world full of Twitter-based solutions.

Here’s a quick prototype from [Travis Goodspeed]. It’s a smart card built around an MSP430 microcontroller. We’ve used the MSP430 in the past because of its low power demands. He says this business card currently supports 1.8V to 3.3V, but a future design will have 5V as well. Technologies like Java Card exist for running applets on smart cards, but a familiar microcontroller like the MSP430 could certainly make development much faster. Knowing [Travis], there’s a reader somewhere about to go through some serious fuzzing.

We’ve heard about the idea of using browsers as distributed computing nodes for a couple years now. It’s only recently, with the race towards faster JavaScript engines in browsers like Chrome that this idea seems useful. [Antimatter15] did a proof of concept JavaScript implementation for reversing hashes. Plura Processing uses a Java applet to do distributed processing. Today, [Ilya Grigorik] posted an example using MapReduce in JavaScript. Google’s MapReduce is designed to support large dataset processing across computing clusters. It’s well suited for situations where computing nodes could go offline randomly (i.e. a browser navigates away from your site). He included a JavaScript snippet and a job server in Ruby. It will be interesting to see if someone comes up with a good use for this; you still need to convince people to keep your page open in the browser though. We’re just saying: try to act surprised when you realize Hack a Day is inexplicably making your processor spike…

[via Slashdot]

When we first saw [Jeffrey Nelson]‘s G1 based robot we immediately wondered what the transport for the controls was. The G1‘s hardware supports USB On-The-Go, but it’s not implemented in Android yet. It turns out he’s actually sending commands by using DTMF tones through the headphone adapter. The audio jack is connected to a DTMF decoder that sends signals to the bot’s Arduino. He wrote client/server code in Java to issue commands to the robot. You can find that code plus a simple schematic on his site. A video of the bot is embedded below.

[via Engadget]

[Josh] sent in a home automation project he did a little while ago. It has a total of eight switched outlets. The main focus of the project was WAP access for remote control from any cellphone. The control box is based on a design by [Ashley Roll] for controlling eight servos using a PIC microcontroller. A listener app written in Java monitors the control web page and sends signals to the board via serial port. He used opto-isolated 240V solid state relays for each of the outlets. All the pieces are available on the site and he might even do a custom control board design if there is enough interest.