Yes, it is what it looks like.
I’m the second owner.
It hasn’t been powered on in 36 years.
I’ll post more pictures as I share the story and test it carefully to make sure it’s safe to power on.
New Arrival
September 3rd, 2012 by Keith NeufeldOS X ATtiny25 Programming Walkthrough
July 7th, 2012 by Keith NeufeldA while back I bought a batch of ATtiny25 microcontrollers and today I finally put one to use and got it programmed. MIT’s High-Low Tech group has put together a really nice package for programming ATtiny45s and ATtiny85s from the Arduino IDE, but it doesn’t support ATtiny25s, presumably because the limited memory doesn’t leave enough space after the bootloader is installed. I had a dickens of a time trying to find instructions to walk through programming an ATtiny25, much less on OS X; but it turned out to be pretty easy after pulling together a few separate resources. Here’s the path to blinkemness.
Hand-Soldering SOIC
July 2nd, 2012 by Keith NeufeldI wouldn’t want to do it for a living, but it’s an enjoyable diversion once in a while, particularly as a favor for a friend.
I aligned each chip’s pins by hand, clamped it to the board with a gator clamp (with heatshrinked jaws), soldered the far row of pins, rotated the board, and soldered the now-far row of pins.
Three rows I was able to do by blob-and-drag (heat the pins at the uphill end of the row, make a big solder blob, and drag it down the row at a pace slow enough to heat the pins but fast enough to keep the surface of the blob from oxidizing too badly, trusting surface tension to bring the blob with you and leave only a lovely solder fillet below each pin). Three rows I ended up doing slop-and-wick (get solder all over the place, then use “Size: Good” solder braid to remove solder bridges from between the pins, leaving a lovely solder fillet below each pin and evidence scorched flux everywhere).
I’d take recommendations on a good flux remover — preferably detailed recommendations indicating whether you have to scrub or just spray, how cleanly it washes off, etc. You can see that the rubbing alcohol I used leaves a bit of residue.
If All You Have Is a Logic Analyzer, Everything Looks Like a Timing Problem
June 27th, 2012 by Keith NeufeldI just rewrote the Arduino Playground Nokia LCD screen code to use hardware SPI instead of ShiftOut(). (More work to do before releasing the code back to the community. And I know, not everyone will want to use the hardware SPI, but it should be an option.)
It looked like a trivial change, but after making it, the display’s screen remained blank.
But … but … but … the slave-select line is supposed to be held low during each byte of transmission. I know the ATmega’s SPI hardware doesn’t manage it for you, but surely the Arduino’s SPI.transfer() function does, right???
Working Arduino SPI Transfer
No. You have to manage it manually.
void LcdWrite(byte dc, byte data) {
digitalWrite(PIN_SS, LOW);
digitalWrite(PIN_DC, dc);
SPI.transfer(data);
digitalWrite(PIN_SS, HIGH);
}
SPI support is a perfect candidate to be a real object-oriented class rather than a functional library in OO clothing. Instantiate objects that know which slave-select pin is theirs, which may have different bit orders and clock rates and clock modes, and provide a transfer() method that sets all the registers, twiddles SS for you, and transfers your byte.
Sigh.
Faster Arduino SPI Transfer
BTW, notice on the second capture that manually bouncing SS using two digitalWrite()s takes longer than transferring eight bits of data using the hardware SPI. Start to understand why I want to transfer data using hardware instead of bit-banging?
Manipulating the SS bit in the port register directly is much faster … at the cost of being much less clear what’s going on to non-native speakers of C.
void LcdWrite(byte dc, byte data) {
PORTB &= ~ (1 << 2);
digitalWrite(PIN_DC, dc);
SPI.transfer(data);
PORTB |= (1 << 2);
}
ATmega I/O Pin Hardware Toggling for Fastest Arduino SPI Transfer (That Isn't Any Faster)
The C-based bit manipulation code above is already fast enough that the timing constraint has moved back to the programmer-selected SPI clocking speed and the ultimate solution -- using the ATmega's hardware-based pin toggle feature -- doesn't save any noticeable time, but the code sure looks cool but it's the right thing to do and it's a risky game to play to assume you always know correctly the logic level of the pin when you enter the function.
void LcdWrite(byte dc, byte data) {
PINB = _BV(PINB2);
digitalWrite(PIN_DC, dc);
SPI.transfer(data);
PINB = _BV(PINB2);
}
(BTW, I had a dream recently -- which I did not know was not real -- in which the latest Arduino release added digitalWrite(pin, TOGGLE) to do the above. Imagine my disappointment tonight to learn it was only a dream. And no, I'm not the first to suggest that feature, by a long shot. Just, maybe, the first to think it had actually happened.)
Arduino-Compatible “Practice”
June 24th, 2012 by Keith NeufeldI’m trying to get my LED calculator out the door this summer, and that requires embedding an Arduino-compatible “core” into my own system. Yes, yes, I could use a microcontroller without the Arduino environment; but if I actually get this thing ready to sell, I want my customers to be able to reprogram it (apply firmware upgrades or enhance the feature set) in a comfortable environment. Hence an Arduino-compatible core.
I haven’t made an Arduino-compatible before, and the only two things I found daunting were the crystal, which I understand has to be exactly matched to its supporting capacitors or the circuit won’t resonate, so it was important to find the same one used in the Arduino; and the resettable polyfuse on the USB power lines, which doesn’t (in the Arduino circuit) specify whether 500 mA is the hold current or the trip current.
I found an Arduino playground post by Tom Igoe giving Digi-Key part numbers for a bare-bones breadboard Arduino-compatible and chased the out-of-stock crystal to the equivalent Digi-Key catalog number 887-1019-ND. I searched far and wide for information on the polyfuse and gave up, settling on 500 mA hold current, since that’s permitted (after negotiation) by the USB spec and surely we wouldn’t want to trip at the maximum permitted current.
With that data in hand, I still had a healthy dose of uncertainty about my likelihood of building a working Arduino-compatible. I prefer to develop and test modularly, so I wanted to assemble a working proof-of-concept Arduino-compatible before diving into the LED calculator project. And as it happens, I had a perfect project waiting in the wings — an Arduino-compatible board with ground and power headers surrounding the normal I/O headers (like servo connectors), to make it easy to connect external sensors without going all-out and buying a sensor shield (which actually has the I/O pin at the end of each connector rather than in the middle, whatever). I want to build my own version of my friend Trevor’s household temperature-monitoring system, and such an Arduino-compatible would be a great platform for terminating the three-wire temperature sensors.
To speed the process, I started with the EAGLE schematic of the Freeduino through-hole design, ripping up the board and laying it out mostly from scratch to make room for my extra header rows. I had the board produced by BatchPCB, I received it last week, and I have now assembled it into a working Arduino-compatible.
But not — this is going to sound soooo familiar — without some snags along the way.
Testing the FTDI USB-Serial
The one component not available in a through-hole package was the FTDI USB-serial chip; and I planned on hand-soldering it; and that’s way easier to do without other components looming over it and getting in the way of the iron; so I attached it first. And that led me to test it first as well, since I test as I go.
BatchPCB
June 17th, 2012 by Keith NeufeldMy academic background is in mathematics and computer science and I’ve picked up electronics as a hobby along the way, primarily self-taught through excellent books by Forrest Mims, the easy crossovers from math and CS to digital logic and digital design (still my strongest area of electronics), a stubborn willingness to read datasheets, and a constant desire to learn.
For the last two years, I’ve been supplementing that with a formal background from my university’s EE department, taking first one and recently two classes per semester. The education is interesting and enlightening, but it does take its toll — at least forty hours a week of work, six hours of classes, and (say) twenty hours of study and homework, plus some volunteer work unrelated to those, doesn’t leave me with a lot of free time; and you can see it by the decline in my hobby activity.
I don’t want to lose sight of what I love, though; and I hope to make a small business of electronics and make a few products available for sale. So this summer I’m devoting every spare moment to get some projects off the ground. And my ally in that plan is BatchPCB.
Why Have Boards Manufactured?
In the past, I’ve done a lot of circuit prototyping on breadboards. For some types of circuits, though, the needed prototyping has more to do with physical form factor and less to do with circuit validation. (I hope to show some examples in the coming weeks.) I’ve etched my own circuit boards; I’ve imposed on friends to mill prototype boards for me; and I’ve hoped to build my own milling machine to prototype my own boards at home.
The drawback of all of these methods is the lack of plated through-holes. I’ve heard of DIY hole-plating methods, but I found them to require a prohibitive setup for chemical processing. I’ve asked everyone I know whether they can think of any source for 1.5-ish mm (60 mil) OD copper or silver tubing, thinking of making a small riveting press to flare tubing onto the PCB surface both top and bottom — and even found very small silver crimp tubes used in beadwork and jewely-making, but none as small as 1.5 mm OD, nor in a consistently appropriate length.
I’ve worked around the lack of plated through holes by laying out boards that don’t require them, always carrying a signal from top to bottom using a component lead that can be soldered on both sides. But this means no vias (soldering pins top and bottom just to change layers is a pain) and only crossing layers at resistors and diodes. It means always routing connections to electrolytic capacitors on the bottom, ’cause you can’t get to the top side of the board to solder unless you stand the capacitors way up on their leads. It means routing traces to headers only on the bottom, or sliding the plastic guide up on the pins to solder the top side and then sliding it back down. It means a dozen little design compromises for a prototype board that don’t need to be made for a board I’m going to have commercially manufactured later. It means not only extra effort to accommodate my prototyping methods but also extra effort to undo that work before going to manufacturing.
SparkFun Electronics created BatchPCB as an offshoot of their own PCB prototyping contract. They aggregate orders from multiple users, tile them together onto standard-sized panels, upload the panels to Gold Phoenix, get the boards manufactured, receive the shipment from Gold Phoenix, sort out the boards, and send them back. They charge $2.50 per square inch, which is higher than you’d pay if you were ordering 100 square inches — but far less than you can pay anywhere else if you only want a few square inches of prototype. And they charge a flat $10 handling fee per order, regardless of how many designs you include in your order.
They suggest it’ll take about three weeks to get your order. My experience has been two weeks. It sounds like a long wait, but as they say:
As we develop projects, we always get at least one PCB design onto the week’s batch panel. While one design is being fabbed, we have new PCBs for another design already arriving from a previous batch – we always have new PCBs to play with!
My Summer with BatchPCB
I’m trying to place an order every two weeks and to order boards for multiple projects each time. I’ve received two batches so far and I submitted a third this weekend.
I’ll say more about these designs as I work on the projects, but starting at the top and progressing in reading order:
- Logic gate boards to help bridge the huge gap between what happens in the digital design lecture and lab. My classmates with no prior experience did not gain much academic value from poking opaque ICs into breadboards.
- A Freeduino-derived board for my personal use, manufactured as a proof-of-concept that I have the right components and schematic to embed an Arduino-compatible core into projects of my own. (I will of course publish all source files for designs that I distribute to anyone other than myself.)
- The first half of a pair of boards to breakout a headphone cable and jack for breadboarding, to plug an iPod’s headphone output into op-amp filter circuits and listen to the results.
- A board for testing component lead fit against through-hole sizes. To date, I’ve used calipers for measuring lead sizes for PCB design. I’m curious whether testing against a physical board gives me any different expenditure of time or quality of results.
The logic gate boards were my first batch. I ordered four each of two variants of the boards, assembled a few, and discovered that I don’t like soldering 0603 SMT as much as I thought I did; so if I make more, I’ll be changing the boards to use 0805 components.
Lesson learned: Order only one of your first prototype, regardless of how sure you think you are that you’ve finalized the design.
So why so many of the other boards? I did order only one of each … but SparkFun, bless their hearts, appears to fill wasted space in each panel with small customer boards that they give back to their customers as a bonus; and I happened to have small designs in this batch.
Motherboard Electrolytic Capacitor Replacement
April 15th, 2012 by Keith NeufeldI’ve been quiet lately because I’ve been too busy … hope to break free of that by mid-May and get back to some projects.
I’ve made time to do a little server work; I’m trying to build a more consistent set and get my servers all up to current OS versions. I have three nice rackmount server cases, and while scrounging ATX motherboards to put into them, I ran across this.
The electrolytic capacitor just to the right of the center of the image is seriously bulging, as is the out-of-focus capacitor behind it. They both test good with the Capacitor Wizard, but I wouldn’t trust either of them with power applied, at least not inside anything I care about. Always at least visually check electrolytics before you power up something that’s been off for a while.
Desoldering was easy — heat both leads and gently rock them out.
Cleaning the solder out of the through-holes was trickier. At least one of the holes was attached to one or more large copper planes and kept sucking away the heat — I had to add solder, keep it preheated with the iron so it stayed liquid through the hole’s whole depth, and quickly slip the solder braid into place. Heating solder braid on top of a topped-off through-hole wicked away the top solder before heating it all the way through.
And then I ran out of solder braid. Ended up drilling out the holes, which I’d wanted to avoid in order to avoid any risk of damaging the plating. But I picked a small enough bit that I didn’t even remove all the solder, and it worked out okay.
The replacement capacitors I had on hand were a little wider and crowd adjacent components, but at least are rated for 105°C like the originals. And they seem to work; the board is now cheerfully running my new backup server.
Notching a Circle in Inkscape
March 3rd, 2012 by Keith NeufeldI needed an SVG and DXF of a circle with notches around the perimeter to laser-cut a diffuser lens and to subtract the lens’s shape from its housing in OpenSCAD. The best tool I had for the job appeared to be Inkscape (in part because I really wanted to do it with an open-source tool so it could be repeated by others), and the method was quite a process of discovery, aided greatly by John Harrison.
Here’s how I did it.
Draw the circle and use the toolbar transforms to set its diameter and position it at the origin. (Since positioning the notching figure correctly on the circle must be done in absolute coordinates, it’s easier to calculate with the circle centered at the origin.)
Draw a shape you want to use to notch the circle (in my case, a square rotated 45 degrees) and use the toolbar transforms to position it to notch the circle (in my case, overlapping by 0.100″, by setting the X coordinate to half the circle’s diameter minus 0.1″). The next step will be easier if you also size the shape so that its bounding box (enclosing rectangle) is an even number of the units you’re using in your coordinate system (inches).
I had hoped, by the way, to do this by insetting a circle by 0.1″ (but I can’t find how to inset by a distance other than pixels, nor to set my inset distance numerically other than zoom way in and watch the mouse position while I drag the inset control point) and then snapping the square’s position to the inset circle (but Inkscape doesn’t appear to snap to geometry).
What I tried next did not work — moving the square’s pivot point to the origin and creating 16 tiled clones of the square with -100% shift X per column and -22.5° rotation per column. (I’ll show those steps later when I describe what actually did work.) For some reason, Inkscape acts as though my pivot point is 0.1045″ left of where it actually is, and I’m not willing to fuss with manually calculating the (in)correct pivot point every time I want to tile by rotation.
Instead, duplicate (Edit / Duplicate or copy/paste) your notching figure and move the copy to the far side, opposite your original, rotating it 180° if need be. Positioning the second notching shape is where the integer-unit-sized bounding box comes in handy — I placed mine with an X coordinate of negative (half my circle’s diameter minus the inset amount plus the notching obect’s box width), or -(4.350″ / 2 – 0.100″ + 1.000″) = -3.075″.
Select and group (Object / Group) the two notching figures. The next step only works on a single object, not on multiple selected objects.
With the grouped notching objects still selected, enter the tiled clones dialog (Edit / Clone / Create Tiled Clones...). On the Symmetry tab, leave P1: simple translation selected, click the Reset button in the lower left to set everything to defaults, and change the number of columns in the Rows, columns to half the number of notches you want (since you’ve grouped two notching figures together already). On the Shift tab, set Shift X to -100% per column. On the Rotation tab, set the Angle Per column to -360° divided by the number of notches you want (-360° / 16 notches = -22.5° / notch). (Apparently Inkscape rotates clockwise for positive angles, the opposite of the entire field of mathematics.)
Click the Create button, note that the lower left of the dialog box tells you how many tiled clones have just been created, and slide the dialog box out of the way to view your results. If it’s not what you expected, click the tiled clones dialog’s Remove button and review and retry your tiling configuration until you get what you want. Once satisfied, close the tiled clone dialog box.
Immediately delete (Edit / Delete or press Delete) the selected figure. The tiled clone tool leaves your original figure selected and makes a copy of it at the original position; you want to delete the original before continuing.
Select everything (Edit / Select All or Ctrl A or drag a box around everything) and ungroup (Object / Ungroup) to isolate your notching figures, as the next step operates on only two shapes at a time.
Select your circle and one of the boxes and do a path difference operation (Path / Difference or Ctrl -). This should carve your notching shape out of the circle. If instead it carves the circle out of your notching shape, undo, then select the circle and lower it to the bottom (Object / Lower to Bottom) before continuing.
The notched circle should remain selected after each difference operation. Continue selecting additional notching figures and taking the difference until you’ve created all your notches. Voilà! (Or “Viola!,” as we say on the Internet.) A notched circle.
Take care if you intend to move the circle to a specific position on your page: its dimensions may have changed, as the dimensions shown are those of the bounding box and any notches on the right, left, top, or bottom may have allowed the bounding box to creep in a bit. You may need to account for this and add a tiny offset to get the center where you want if you’re positioning the notched circle numerically.
Better Ways?
If you know an easier way to do this, I’d love to hear about it in a comment. Please try your method, right now, before posting a suggestion. It’s too easy to think something will work, or think you remember the exact details, and with the best intentions still mislead people. Always always always test your technical advice before posting it.
Why I don’t buy Duracell, Energizer, Eveready, or Rayovac
February 18th, 2012 by Keith Neufeld
I was given this high-quality, hefty, well-balanced, well-performing LED flashlight several years ago with batteries already in it. I keep it in the glovebox; and recently when I needed it, it didn’t power on.
In my decades of using consumer electronics, there’s only one brand of alkaline cells that has never leaked in my equipment — even things I’ve forgotten about and found again years later — and I drive miles out of my way to buy them.
Doubtless someone will pop up with their own horror story, but I’ll still make the claim: You will never, ever, need this.
Cleaning the Flashlight
In order to get out the crud, I disassembled the flashlight completely and cleaned it with a wire brush, a wire wheel on the Dremel, a wire brush on the Dremel, and a toothbrush and dishwashing detergent. I went a little overboard to make sure I had got it all, but at every stage I was getting out more crud.
I’ve long been impressed with the heft and solidity of the flashlight; now that I’ve seen the inside, I’m equally impressed with its design and with the ease of (dis)assembly.
Loosely clockwise from the left, the reflector isn’t adjustable for beam focus but screws off anyway. The heatsinked LED has a separate plastic housing with beveled forward edge that centers the LED against the back side of its reflector cone. The LED housing’s retaining ring doubles as one of the LED terminals.
The aluminum head holds the LED housing and the separate LED driver housing, dropped in from the tail end, and screws tightly to the reflector. The plastic housing for the tiny power switch and LED driver board is made of two identical, completely reversible parts, holding in the inner power switch pushbutton on the one side and leaving a window to check board orientation for assembly on the other.
The rubber outer power switch pushbutton installs after the LED driver is dropped into the head and does not seal against the housing, suggesting that the o-rings on the aluminum housing are for a great feel during assembly and battery replacement rather than for water resistance.
The battery cage holds three AAA cells and assembles easily. The stiles are marked with the cell orientation; the filled cage looks a bit like a C cell and drops into the flashlight handle, with the spring-loaded button and the metal ring contacting corresponding surfaces on the bottom of the LED board.
The tail cap doesn’t make electrical contact with the battery’s negative terminal and the flashlight body doesn’t conduct current, as it does on many less expensive flashlights (not that I think I care).
Cleaned, reassembled, and with AAA cells reinstalled, it once again works perfectly. I look forward to many more years of service … and to not having to clean it out again.
Rebuilding the CupCake Extruder Heater (When It Wasn’t Very Broken)
January 29th, 2012 by Keith NeufeldAfter some success back in June using fans to cool extruded layers on my CupCake — in fact, right after that success — it slowed extruding and eventually stopped extruding altogether. This is the story of my life with the CupCake — a very brief success from time to time, but never persistent nor replicable.
When I say stopped extruding, I mean the motor actually ground to a halt. Usually it chews a divot into the filament, but this time it stopped. And I was pretty sure — don’t remember whether I actually checked the on-screen display or not — that the nozzle temperature had dropped and the filament wasn’t melting any more.
I know people talk about extruding ABS at temperatures as low as 200°C, and I don’t find that to be the case in my CupCake. Mine is calibrated, and mine doesn’t like temperatures that it thinks are lower than 220°C, and mine doesn’t really like temperatures that it thinks are below 225°C. So it really doesn’t take much to make it unhappy.
I had just rebuilt and rewound my heater at the time, and I knew that I had crimped the nichrome to the teflon-coated lead wires with silver crimp beads. I had a suspicion that the joints had become oxidized under the crimps, and the 7.3Ω resistance across my heater wires seemed high for my CupCake.
A couple of weeks ago I disassembled the heater and found that one of the two connections was indeed quite scorched and oxidized.
After cutting away the crimp tubes, cleaning the end of the nichrome wire with fine sandpaper, cutting back the lead wire, and recrimping, I tinned both lead wires with solder. Solder doesn’t stick to nichrome; but being coated with solder, the joint (which already had a solid mechanical connection from crimping) should be much less prone to oxidation.
After the rebuild, the heater measured 6.8Ω. Half an ohm difference doesn’t sound like that much until you’re trying to get to 225°C. Since power P = V2 / R, at 7.3Ω, P = (12V)2 / 7.3Ω ≈ 19.7W; and at 6.8Ω, P = (12V)2 / 6.8Ω ≈ 21.2W; so maybe that could be enough to make the difference at the high end of the extruder’s temperature range.
Aaaand … after reconnecting things, I still couldn’t get the temperature above 222-223°C, even though it now had some 7% more power. That doesn’t seem quite right.
When in doubt, scope it out. Yeah, after almost a full minute of failing to hold the temperature at the set point, the software PWM in the extruder controller was still running the heater at about a 50% duty cycle. That definitely doesn’t seem quite right.
And isn’t something I can easily fix, either. The ReplicatorG version I was running didn’t have a control panel for the heater PID settings, so (even assuming I was smart enough to fiddle them into shape) I would have had to recompile the code each time I wanted to make a tweak, which wasn’t palatable.
Firmware Upgrade
But I thought I’d heard that newer ReplicatorG versions did bring the PID coefficients into the machine control panel, so I upgraded ReplicatorG from 0024 to 0029r2, and let it upgrade my firmware from v2.4 (I think) to v3.0, and lo! lost communication between ReplicatorG and the CupCake. It said it had a connection but all the menu options to talk to the CupCake were greyed out.
Great.
This is apparently a known problem claimed to have something to do with the Mac’s localization settings for the string representation of “,” and “.” in numbers. Srsly? And the suggested tweaks didn’t fix it for me, so I’ll just wait for the next ReplicatorG release. And since the Mac package of ReplicatorG continues to be a DMG file of all the pieces you have to drag into /Applications/ReplicatorG, rather than a ReplicatorG folder that one could conveniently drag into /Applications like everyone else provides … I guess I should feel lucky to have a Mac version at all, and I’m not holding my breath for a fix on this problem.
Anyway, downgrading ReplicatorG to 0026 restored my connectivity and got me a look at those sweet, sweet PID coefficients.
Which I no longer need, ’cause with the upgraded CupCake firmware, the PID algorithm seems to work right. Reaching for the knobs was obviously an attempt at a workaround, and the real fix is oh so much better.
The stringing on this diffusing filter holder is my fault, not my machine’s — I have a 0° (or 90°) overhang on a concave curve, so there’s no way it was going to come out clean. I still wanted to see what it would do, and it performed admirably under the circumstances of an impossible model.
And then stopped working again.
Filament drive motor locked up against the filament. A-gain. (Yay, great grip on the drive pulley, and nozzle retaining washer not breaking!) Temperature claims to be steady where set.
My utility is fairly cold these days. I’ll try enclosing the build chamber again in hopes that although the nozzle is hot enough, the teflon tube is too cold — but I bet I end up disassembling and drilling out the inside of the tube and nozzle again.
Should have been designed with a quick-release.