As we planned for Christmas this year, my partner suggested that maybe we should replace the lights for the tree. “While we’re at it,” she asked, “is there anything out there that’s more controllable than just the ones that twinkle on and off?”
“Well,” I said, “there are NeoPixels…”
We decided that it would be great to have a tree where the lights looked and acted like candles, flickering gently in a soft, warm glow, and fading from a bright orange down to a low reddish glow by the end of the evening. We also wanted to realize the cheesy quote from It’s A Wonderful Life that “every time a bell rings, an angel gets its wings.”
Here’s a timelapse of the tree in action:
When you ring the bell, this happens:
The process of making it gave a chance to work with:
You can find the code and circuit in the gitHub repository for this project.
Continue reading “Programming a Christmas Tree”
Peter Knight works with Massimo and Alex and co. at Tinker.it. He’s written some great AVR code, which is useful in Arduino. For example:
Secret Thermometer takes advantage of the ATMega’s internal thermometer. Turns your ‘328-based Arduino into a thermometer with no extra parts.
Secret Voltmeter same idea, but this reads the internal analog-to-digital converter to tell you the Arduino’s supply voltage. Also works on the ATMega168.
He’s also done Cantarino, a speech synthesis engine; Auduino, a granular sound synthesis engine; a DMX library; and more. Check them all out at the tinker.it code repository.
This example shows how to control 64 LEDs and read the input from two axes of an accelerometer on an Arduino. The Arduino used here is a Duemilanove, but it will work on any of the models out there prior to the Duemilanove as well. This example uses row-column scanning as a way to control more LEDs than you have output pins. It also uses some of the analog pins as digital I/O pins.
Parts you’ll need
Created 31 March 2009, edited 1 Nov 2020
Once you’ve mastered microcontroller programming, you might be tempted to control a lot of LEDs. Lots of people have this desire once they master the basics. Many microcontrollers have a limited number of output pins, however, so you might think that limits how many LEDs you can control. I’ve written about a few different methods around this before in chapter 14 of Physical Computing and in this blog.
By matrixing your LEDs, you can control many more than the number of pins you have. For example, with the Arduino Uno and earlier models, you had up to 20 digital outputs (13 labeled digital I/O 0 through 13, plus the six analog outputs, which double as digital I/O 14 through 19). With 16 of those, you can control an 8×8 matrix of LEDs. That’s 64 LEDs. With the Arduino Mega, you have 54 digital I/O pins, so you can control a lot more. This example uses 32 of them to control 2 8×8 matrices, for a total of 128 LEDs from one controller.
To make this example, you’ll need:
- Arduino Mega
- Breadboard or prototyping shield.
- 8×8 LED matrix. I got mine in a surplus shop in China, but you can also get them from most electronics retailers
- male pin headers
- female pin headers
Step 1: Figure out the LED Matrix pins
Continue reading “8×8 LED matrix control on an Arduino Mega”
There was an interesting thread on the Sketching in Hardware mailing list a while back on how to control an inkjet printer. Wendy Ju started the discussion. Following are some of the links from that thread:
A closed, proprietary portable printer: Xyron Design Runner
Nice explanation of how inkjets work and how to control them in general. Link submitted by Scott Minneman
Instructions for now sold-out Parallax Serial Inkjet Kit (which does include inkjet cartridge pinouts for the HP 51604A Black Inkjet Cartridge, as well as board schematics, parts and instruction routines for writing to the cartridge). Even without the device, Parallax’ documentation is handy.
Instructions on how to build your own DNA microarrayer using commercial off-the-shelf parts, including inkjet technologies. The last two links submitted by Wendy.
Haven’t had occasion to use these yet, but they seem handy.
Kimio Kosaka has made a way to program a virgin Atmega168 without a hardware programmer.Â You use a modified version of the avrdude programming software that can access the extra pins of an FTDI USB-to-serial chip, do a little soldering on your Diecimila, and Bob’s your uncle, as the Italians say.
Calculating the configuration fuses for microcontrollers is always a pain. Many programming environments can do this for you, but in case yours doesn’t, here’s a handy fuse calculator for calculating the fuses on Atmel’s AVR microcontrollers.
Thanks to Zach Eveland for the link.
Most microcontrollers don’t have a random function. Random functions are not truly random, they’re actually a complex mathematical formula that results in a number that “seems” random. That can take up lots of processing time, so it’s usually the first function to go when writing a microprocessor language.
In fact, most of what you do in programming physical computing projects is to figure out how to deal with the world’s natural randomness and make it look smooth. A photoresistor read through an analog-to-digital converter, for example, will never give you a nice steady number, it always fluctuates with tiny changes in lighting that your eye can’t see. Your consciousness is a great leveller for the sensors that are your eyes, ears, skin, nose, and taste buds When you move a photoresistor from one room to another, your readings will be totally different, and all of a sudden, you have to re-calculate what is “average” and what constitutes the lighting change that you want. And that’s just one of many examples. The fact is, data from sensors is filled with the noise of the real world. Plan for it in advance.
Technorati Tags: pcomp, physical computing, programming
Continue reading “Random Numbers and Physical Computing”