Build a photo studio - Collapsible Light Diffuser Frames

I just published my first instructable, a collapsible light diffuser for photography.

Click here to go to the Instructable.
Click here to go to the photo gallery page.

I'll be posting some photos later that we took using this. We cataloged all of the knitting Erica has completed so far, and we wanted to make this for the photos.

Let me know what you think.


ah, math

Look at the great bit of math the computer gave us for total travel time.

Flight to Boston
Flight: 2 Round-Trip Tickets
All flight times are local to each city.

Seattle/Tacoma International Airport, (SEA) to Boston Logan International Airport, (BOS)

Flight: Alaska Airlines Flight 12 (on Boeing 737-800)
Depart: 08:45 AM, Seattle/Tacoma, WA (SEA)
Arrive: 05:03 PM, Boston, MA (BOS)

Total Travel Time: 8 hrs 18 mins

Boston Logan International Airport, (BOS) to Seattle/Tacoma International Airport, (SEA)

Flight: Alaska Airlines Flight 15 (on Boeing 737-800)
Depart: 06:05 PM, Boston, MA (BOS)
Arrive: 09:23 PM, Seattle/Tacoma, WA (SEA)

Total Travel Time: 3 hrs 18 mins

So, we're averaging 300 mph on the way there and 750 mph on the way back. (Keep in mind that Mach 1 is 761 mph). Air travel really is amazing these days.

Stupid, or just Crazy?

I've been thinking more an=bout my PID motor controllers based on the ATtiny13, and have determined that I must be crazy. I did some googling, and everyone else that is making a motor controller using an AVR is using something like an ATmega168, an ATmega32, or other large controller (almost always a mega). The application note on Atmel's website (look for AVR221) doesn't recommend a certain controller at all. So am I crazy to try to shove this all into an tiny13? We'll see how it goes.

I went over to AVRfreaks.net to see if there is anything larger than the tiny13 that has the same pinout. It looks like I can use the ATtiny25, ATtiny45, or ATtiny85 for 2, 4, or 8kb of Flash space. Too bad I already bought a dozen tiny13 chips.


Project Lull

I am officially in a project lull. The microscale is pretty much done (I do need to send it with Erica for final testing), and Robotics season is starting up in the first week of Jan. I theoretically have a week and a half that I could accomplish something with, but I don't have any good ideas.

My micromouse board is at a difficult point. I managed to set some of the fuses wrong, and now I can't talk to two of the three boards. I have one spare processor, so I could replace one, but TQFP-64 is no fun to remove from a board with no soldermask. The alternative is to guess what I set the fuses to, and try to generate the required clock long enough to make them normal again.

I could always work on the program for the micromouse motor controllers, since I have a few of those built up. I can always use an oragutan to test those. After the fun I had implementing PID, UART, and LCD code in an ATMEGA48 (4k codespace, 512B SRAM), it should be quite a bit of fun to put PID and UART into an ATTINY13 (1k codespace, 64B SRAM). at least most of the problem was LCD code. I also need to work in PWM for the speed control, but an interrupt should be able to handle that.

Possible control algorithm notes (while I'm thinking about it):
position registers are basis of PID
  • Current position
  • Final Target position
  • Moving Target position
"moving target" is how I can do speed control. It is the point that the PID errors are calculated against. It moves at a (likely) steady rate towards the Final Target. This is a place where I could put in some acceleration control, but codespace already seems at a premium. The rate at which it moves would be the speed command (counts per small unit of time). This might be the part where I find out why moving slowly is apparently difficult. We'll have to wait and see.

PID normally has just those three gains (P, I, D). I think I might want to try to implement some of the more complex gain types like velocity feed-forward.

This might be a good point to bring up the fact that I plan on using avr-gcc, and not learning assembly for AVR. (One of the best things Atmel has done is to build avr-gcc into AVR studio, IMHO.)

Perhaps I can find some time this week to work on the motor controllers. Remind me to post later about the design of the board itself, and some of the good and not-so-good things I learned while doing it. (Preview of not-so-good: For some reason, Atmel decided to make the SPI programming pins on an ATMEGA128 NOT the same as the normal SPI pins, which caused hours of frustration while debugging the first time I turned it on. Of course I used the SPI programming pins for some completely different function on the board.)


microscale parts list

I saw a link on the MAKE:blog for Octopart, and though it might be a good way to publish a list of the parts I used in the microscale. The only thing I couldn't find was a simple cheap analog meter, like the one from Radio Shack.

powered by octopart

Blog Fodder

Erica sent me an email titled Blog Fodder with some pictures of the microscale in action.

And she also gave me a nice graph of a few sample runs

It's clear that the scale can be improved, but is pretty close to working now. Erica brought it home for me to work on. I think I have enough code space left to add the Derivative and Integral terms back into the PID loop, which should make it less noisy.

I also want to compensate for flag position in the final readout formula, so it can predict what the mass would be if it were perfectly balanced. This part is harder, and I'm not sure if it's needed.