As of Arduino 1.0, interrupts are not supported on the Arduino Leonardo. I’m working on a project using the atmega32u4 with the Arduino IDE which needs interrupt support for both software serial and frequency counting, so I investigated ways to add interrupt support for this device. I began by checking out the Leonardo pins definition file to see what was missing for interrupt support. Long story short, I ended up copying the macros for interrupt bitmasks/registers from the Teensyduino project, which has a mega32u4 target board. In addition to modifying the pin definition header file, I also needed to modify WInterrupts.c—swapping out the default AttachInterrupt() and DetachInterrupt() funcitons with those from the Teensyduino project.

I have included links below to the pin definition header file and interrupt functions in my project repository. Place these files in the hardware/arduino/core and hardware/arduino/variants/leonardo folders. Note that my current revision of these files only support the m32u4, interrupt support for other devices is broken. You can throw some #ifdefs in there and include the existing code to support devices other than the m32u4, I will hopefully get around to adding this in the coming weeks.

I also want to get SoftwareSerial up and running on the m32u4; I’ll be looking into the Teensyduino variant of NewSoftSerial this week, check back for more updates in the coming days.

Downloads

• WInterrupts.c
• pins_arduino.h

The first prototype ZonCoffee v3 boards have arrived and are nearly up and running. I’m currently porting the code over to Arduino 1.0, as this board uses the Arduino Leonardo bootloader. Read on past the break for more info on the new board.

v3 Features:

• 6-Pin AUX port allows use of parallel LCD or custom expansion
• Supports SparkFun serial LCD
• USB port emulates virtual serial port for logging and loading new firmware
• All ports broken out to screw terminals
• Power via USB or external independent power source
• MAX6675-compatible footprint (also supports Maxim-IC’s newer chips)
• 6-Pin ICSP header for flashing custom bootloaders
• Main power and USB power LED indicators

This PCB includes connectors for external power, a SparkFun serial LCD, a pusbutton encoder, a thermocouple probe, a solid-state relay, and an auxiliary port. The auxiliary port pins are all connected to the ADC, allowing additional analog or digital IO for expansion. Note that the logo is silkscreened backwards, which is the only (thankfully superficial!) problem I have encountered with my board so far.

The PCB is populated with an ATMEGA32u4, an 8-bit Automotive-grade microcontroller from Atmel that features a USB interface as well as USART and SPI. This board takes advantage of USART for the SparkFun serial LCD, SPI for interfacing with the MAX6675 thermocouple interface chip, and USB for logging and updating firmware with a computer.  All parts on the PCB aside from headers are surface-mount, allowing a very compact design. For permanent installation, screw terminals can be depopulated and wires soldered directly to the board (except for the thermocouple leads, which cannot be soldered).

I have fully populated and tested two of these PCBs so far, and everything is completely functional. There are still a few software quirks from porting my original code to Arduino 1.0, but the boards themselves are fully functional. After a bit of tweaking with the encoder library and creating a drop-in library for attaching a HD44780 LCD to the auxiliary port, this design should be completely usable. I have one board up and running on my espresso machine for both use and development, and I also have a board attached to my roaster (modified Poppery I) that I will be using to experiment with ramping the setpoint for temperature-controlled coffee roasting.

Want to get one?

I’m planning on making a small beta run of boards in the coming months. Drop me an email or a comment below if you’re interested. I haven’t priced the beta boards out yet, but they will be available at a reduced price as long as you’re willing to provide a bit of feedback on the system.

I acquired a free Sigma 24-70 f/2.8 lens that had a few issues–namely, autofocus was broken and the zoom was incredibly hard to turn. After using the lens in full manual for a while, I determined that I would attempt to repair it.

I first did a quick disassembly of the mount, exposing the autofocus motor and the top of the lens components. It was clear that the metal bracket on the AF/MF switch was broken, one of the metal arms that push down the gear was dangling from the bracket. I removed the bracket and mixed up some J-B weld to glue the pieces back together.

After some googling, I determined that the lens must have already been disassembled for repair (made apparent by scuff marks on screws) as the spring that engages AF was on the wrong side of the gear. This resulted in the bracket pushing down on the gear rather than pulling it up against the spring’s force, causing the bracket to break.

After gluing up the bracket, I continued disassembly to see if I could do anything about the sticky zoom. Taking the remainder of the lens apart was tough, as Sigma lenses have soldered-on ribbon cables instead of nice detachable ribbon cables like all Canon lenses have. In addition, you must remove a single setscrew to take off the zoom ring which is hidden under the zoom ring’s rubber grip.

When removing the bottom of the lens, I pulled a bit too hard and ripped the aperture drive motor ribbon cable–I didn’t even notice I had broken it until I looked inside the disassembled lens body. Be incredibly careful when pulling apart separate pieces–these ribbon cables are very fragile! I left the aperture cable broken for the time being, as it will take a fairly long amount of time to solder back up. Note: be very careful when removing focus/zoom rings from your lens, zoom/focus encoder brushes are also very fragile.

When I reached the zoom portion, I found several small plastic bushings which were apparently crushed. The previous owner of the lens must have dropped it, crushing the bushings and skewing the alignment of the zoom. Several screws for these bushings were loose, and tightening them did make the zoom a bit easier to use. However, I could not do any more to fix the stuck zoom issue.

I also noticed that the encoder brushes for the focus assembly were bent and broken. I attempted to bend these brushes back in, but I was largely unsuccessful. I couldn’t find any replacement brushes online that matched the brushes in this lens, so I left them as-is. Interestingly enough, AF worked fine without the encoder brushes.

After waiting for the J-B weld to cure, I reassembled the lens with the spring in the right location and tested it out. AF worked properly, and the zoom was a bit easier to use. Other than the aperture being stuck at F/2.8, this was a very usable lens.

I have since repaired the broken aperture cable, and I’ll throw together a post on that procedure in the near future.

When you’re trying to grow a bunch of plants in a field where a water source is lacking, things can be a bit tough. Hauling water on-site is a very arduous process, even with a tractor/trailer full of buckets. After hauling 5-gallon buckets to water blueberry bushes for months, we began to work on a better reservoir irrigation system that was cheap and easy to automate with expandable capacity.

To store water, we decided to use a 55-gallon drum. The drum provides enough water for just over a week of watering every other day. We plan on adding another barrel with a siphon hose connecting it to the main barrel for additional capacity.

After deciding that a gravity-fed system would be inadequate, we purchased a very inexpensive 1250 GPH bilge pump. As cheap as it is, this pump provides enough pressure to water an entire row of blueberry bushes. If you are planning on a more extensive system, you likely need a more powerful pump (more about this later).

We added garden-hose threaded adapters to both the hose of our bilge pump and the intake of our watering line. Having a garden hose adapter for the bilge pump line allows us to use garden hose and sprayer nozzles to water other plants, if needed. Note that an in-line anti-siphon valve is necessary to prevent water from constantly flowing out–we eventually added one after these photos were taken.

We used standard black irrigation tubing and spray nozzles for our watering lines. This hose is incredibly cheap and the spray nozzles are about $.50 apiece. These nozzles are adjustable, allowing them to work with the very low water pressure that the bilge pump provides. Our watering hoses are laid on the ground, however lines can be suspended over plants on stakes if necessary (this help keeps dirt and other particles out of the nozzles).

We terminated the end of our watering line with a garden hose connector as well, mating nicely with the connector on the bilge pump hose.

We laid our tubing along the ground without stakes initially, however we ended up staking down the hose between every nozzle to keep it from moving around.

The setup itself is not incredibly unsightly and does a great job of watering plants in locations that don’t have a source of water close by. If the barrel is topped up every so often, watering is quick and easy.

Future Plans

In the near future (likely next season), I plan on adding automation to the system with a relay, microcontroller, and RTC chip. I am developing this system while at school for my small-scale indoor automated watering solution (documentation to come soon).

In addition, we have purchased an RV pressure-regulated water pump with much greater capacity, allowing us to water more plants and some of our fruit trees next season. If you need greater capacity for your watering system, you can buy one of these pumps for about $50 on eBay. If you need greater water capacity, you can add additional 55-gallon barrels with siphon hoses between them. This is an easy way to increase capacity without making any changes to your existing system.

MNL is a multi-node high-power RGB lighting system. It consists of a controller (PC or embedded system) and multiple light nodes networked with RS485. The first prototype nodes are up and running, and we will be developing the second revision of prototypes in the coming months. Read on past the break for more information.

Node Hardware

The node board is a small PCB with two RJ-45 ports and a power terminal strip, along with an ICSP header for flashing firmware. The nodes are designed for daisy-chaining both data and power.

Current features:

• RS485 communication
• Supports LEDs of up to 1.2A per channel
• Upgradeable firmware for additional features
• TBD: Firmware updates over RS485
• Multiple fade types, dwell modes, etc.
• Hardware-agnostic network supports different types of nodes (e.g., strobe, motor driver, etc)

LED Circuit

The LED used for prototyping is a 10W RGB LED from DealExtreme, which provides a generous amount of light with low cost per lumen. Although the heatsink is a bit small, forced-air cooling keeps things at a reasonable temperature.  The PCB includes a fan output which is PWMed according to the average instantaneous luminosity of the node. Forced-air cooling could be helpful for installation in compromising environments, such as can lighting fixtures.

The current design incorporates 3 current-limiting resistors for each channel of the LED. Although this is less efficient than current-regulated supplies, it allows flexibility in LED choice without requiring extensive PCB modifications.

Prototype Software

I developed a quick Processing sketch for testing purposes. It creates a FFT of the stereo mix and uses the lowest three bins to determine R/G/B brightness. If the largest of the three values is over the threshold specified by the slider, then an update command is sent to the node. The processing sketch also has an Open Sound Control (OSC) interface, allowing easy control from the TouchOSC app for iPhone or Android over WIFI as well as any software package that supports OSC.

This project is still under heavy development, and is still in the prototype phase. We are adding additional features to the software and hardware, so expect significant updates in the coming months.

Want a nice hearty printed circuit board desktop background? Well, here you go (right-click, save as). The PCB is an older Arduino NG board placed on top of one of our 10W MNLC lighting nodes (still under development, more information to come).

tinyRGB is a minimalist blinkM-compatible high-current i2c RGB LED controller consisting of only 10 basic components. The board is small and inexpensive, can be fabricated for as little as $1/board, and can easily be assembled by hand with a total component cost of around $3.

tinyRGB runs the cyz_rgb firmware, providing a simple interface that is completely compatible with blinkM commands.

This board is designed to run on 5v, which is also exposed on the LED output header. However, this board can easily be used to drive LEDs at higher voltages by providing a higher voltage to the common cathode of the LED.

Parts:

• PCB [$1]
• Pin Headers (if desired)
• 3x 2N6427 1.2A / 40V NPN Transistor [$.04, mouser]
• ATTINY85 PDIP [$1.82, mouser]
• .1uF 0805 decoupling capacitor (optional) [$.06, mouser]
• 3x 0805 Surface-mount 1k resistors [$.04, mouser] (yes, you really can solder them with a fat wedge tip!)
• 3x current-limiting resistors matched to your LEDs

Total cost: ~$3, plus the cost of your LED and current-limiting resistors.

For firmware installation and setup instructions see the “build” section of Multi-Node Lighting.

Board and schematic downloads are included below. Note that the board is a bit rough around the edges (figuratively), and could use some improvement. Drop comments below if you have any suggestions.

Downloads:

• EAGLE Schematic
• EAGLE Board

The ZonCoffee espresso PID controller board has been fabbed!

The silkscreen on the board was a bit messed up; both the names layer and my text layers were screened on the board. Nevertheless, the board appears to be very well-manufactured, and I will have a board populated for testing in the near future. The EAGLE brd file and other information will be posted as I have time.

This project uses the open-source i2c RGB LED controller firmware “cyz_rgb” to create a modular high-power lighting network. The network is controlled by an Arduino, which scans the network for nodes controls them autonomously with onboard scripts, manually via serial console control, or over the serial computer-control interface for interaction with programs on a host machine.

Node: BlinkM Clone

Hardware

Each node consists of only a few inexpensive components. The total cost of each node, not including shipping or bulk discounts, is around $5.50. If you order more than 3 of the 3W LEDs, the price drops drastically ($2.74 per LED and lower.

• ATTINY85 - $1.82 – Cheap, small footprint, plenty of memory.
• 3W RGB LED from DealExtreme – $3.35
• NPN Darlington transistors (only $.04 from Mouser!)
• 10uF decoupling capacitor
• Current-limiting resistors for each LED (must be 2W+ rated!)
• Optional: Pin header, screw terminal, reset switch

Initial Prototype on protoboard (resistors have been upgraded to 2W in the final boards)

The initial prototype node boards are shown below. These nodes include non-standard programming headers, screw-terminal power connectors, and incredibly under-rated resistors (1/4 watt for the red LED resistor!). 2W+ rated resistors are necessary if you are using a 3W+ LED. I would also recommend adding terminals for the clock and data lines, unless you want to run ribbon cable between the ICSP headers of each board which, conveniently enough, breaks out the needed power and data lines.

Controller: MNLC

The controller for the network of i2c-connected nodes is an Arduino running MNLC. This sketch provides a simple serial terminal for manually communicating with the network of nodes, and also provides a non-interactive serial mode for host computer control. Included for testing is some code from jarv.org which reads an analog audio signal and cycles the network of LEDs through various patterns based on the amplitude of the incoming signal.

Fully assembled prototype board with proper resistors

Build your own:

1. Assemble node(s) as shown in schematic above
2. Connect programmer to each node and flash ATTINY85 chips with cyz_rgb_slave firmware
3. Unset the divide clock by 8 (DIV8) fuse on each node
4. Assemble audio input circuit (if needed) and flash Arduino with MNLC
5. One at a time, connect each node to the Arduino
6. Once the node is connected, enter the interactive serial interface and use the “i” command to set a unique address for each node.
7. Daisy-chain clock and data lines of all nodes to the Arduino, add pull-up resistors on both the data and clock line, and run MNLC sketch

Additional information on the construction of the final design and some notes about scaling this project up to a 12-node network with considerable distance between nodes will be added in the near future.

SlatePermutate is a PHP and Javascript-driven interface for college class scheduling. SP parses course identifiers (such as MATH-2500) and autofills all available sections associated with the course. After submission, SlatePermutate presents a tabbed interface of all possible schedules, course conflicts excluded.

SlatePermutate currently supports autofill for:

• Cedarville University
• Calvin College
• University of Michigan (beta)
• Michigan State (beta)
• Community College of Baltimore County

Support for additional schools is progressing incrementally.

SlatePermutate is deployed at Cedarville University and Calvin College, with a deployment on Protofusion available as well. Note that deployments at individual schools will not necessarily crawl course data from all supported institutions.

• Project Information
• Bug Tracker