Hypomnemata

We’ve found a bug in the Volksduino v1.2 PCB, related to the power jack. There is no danger to power supplies or the Volksduino if you plug in a power adaptor: the problem is actually that the jack isn’t actually connected to the circuit correctly. This is a problem with the 1.2 Volksduinos, which are nearly sold out, so we don’t anticipate many problems with this. This post is mostly for anyone who happens to want to add power to an older Volksduino at some point in the future.

First off: sorry! We screwed up. The original Volksduino (v1.0) had a few problems, which were fixed in v1.2. Somehow, this one slipped through the cracks. We’re especially sorry that it took so long to find this out and document it. Since we don’t usually include the barrel jack (in our experience, no one uses it, and it’s one of the hardest parts to solder for new solderers), it took nearly the full first production run of the v1.2 for someone to notice it. In any case, this is entirely our fault, and we’re working with folks who are affected to try and make things right. There isn’t a Volksduino 1.3 in the plans at the moment, unfortunately (we’re focusing on other products, which are a bit more “different” than Yet Another Arduino Clone).

Anyway, let’s get down to fixing this thing. The problem is with the pinout of the barrel connector. Instead of connecting the power input to the ring and center pin (ie: ground and positive voltage), it’s connected to ground and the “power supply is plugged in” switch. There is no danger to your power supply or stock Volksduino: it’s just that the wallwart’s positive supply isn’t really connected to anything.

The problem is that the wrong pinout was used for the power jack, so we need to cut one trace (“wire” on the PCB) and run a quick jumper from the jack. Here are images of the two step:

1. Cut the trace, (and where to do it, and what a cut trace looks like):

2. Run a jumper wire between these two points:

Fuller details:

Tools needed to fix this:

• Multimeter for continuity testing
• X-acto or similar sharp, maneuverable knife
• soldering iron
• solder wick (radio shack has it)
• short length of wire, preferably 22 or 20gage stranded

Problem description: the power jack pinout is wrong. We need to cut the socket-D1 trace and add a jumper from VIN+ to the barrel jack terminal closest to the 7805.

A quick, overly thorough textual walk-through:

1. Test for continuity between the left/outside VIN pin and the bottom pin of the power socket (on the top of the board, it has “7~15VDC” printed through it). On a stock board, this will be a short.
2. On the top of the board, there’s a trace running between the socket and D1′s anode (right under the letter “1″ in “1N4004″). Between the socket and the diode (ie: right next to the socket), cut this trace with the x-acto knife. This is a very thin layer of soft copper under a thin layer of soldermask, so you don’t need to press hard. It’s sometimes helpful to make two angled cuts, cutting a “v” in there.
3. Once this is cut, test continuity again. If it’s still connected, try making your cuts a little deeper. Keep going until these aren’t connected.
4. Flip the board over, and use solder wick to remove a lot of solder from the socket pin closest to the 7805 (it’s on the left when the board is flipped over). We want to get to the little hole in the terminal, so it shouldn’t require pulling off too much solder.
5. If the little hole doesn’t want to clear out, heat up the solder, and gently tap the edge of the board on the table. It’ll probably come loose.
6. Make a short jumper of wire, just long enough to go into the outside hole of VIN and run through this hole.
7. Solder that wire in.
8. Plugging in the wall wart should now light the power LED.

Make sure to keep the wire short, and that the insulation covers things well, which makes this a reliable repair.

If you run into any questions or problems, email support@appliedplatonics.com and we’ll get everything sorted out. Apologies again for the bug!

TI recently announced a new entry in the hobbyist microcontroller space, the TI LaunchPad, which is targeted at the Arduino market.  I don’t believe it’s going to make much of a dent, though.  I spent a while looking at the LaunchPad. I like the idea of it, and I love that TI is doing something to make devices cheaper and therefore more accessible (which is why I built the Breaduino and Volksduino kits, low-cost, accessible Arduino clones). After my initial excitement, though, I’m feeling pretty negative about the device’s future.

(Shameless plug: order the Volksduino kit for $20!)

The kit is a $4.30 purchase, which sounds great, until you find out what’s in it: everything.  Not great, but incredible!  It’s got a USB programmer, a couple of MSP430 Value Line microcontrollers, the development environments.  It even includes the USB cable, and comes in a nice box.  The website has an unboxing video, which is … odd, for a uC dev kit.  Overall, this is a fantastic value, and a wonderful development kit.  If the IDEs are remotely friendly, it makes a compelling first device.

First off, they must be taking a loss on every one of these. I priced out building a knock-off of just the carrier board (without all the control electronics, though with a regulator). I can’t do a kit for less than $4.50*, not including the actual MSP430 chips.  True, they’re using all their own parts, so it’s probably not more than $6 a board, but, still, it’s impossible for anyone but TI to make the main board with their pricing.  This locks up the core of the ecosystem, but might be okay: people can make stations (what I’m calling “shields” for this board).

Judging from the photos, the footprint is 2″x2″, with the header rows at 1.8″ apart. This is just a tad larger than the little Radio Shack protoboards, but not small enough to make the larger protoboards look “at home” docked to the top of it. Their pin layout is suitable for doing stations, but it’s teensy. The Arduino shield footprint is annoyingly small, and this thing is smaller still. And, of course, these microcontrollers have a lot fewer GPIO and analog inputs  than the Atmegas, so you can’t do a useful station-shield adapter board. Beyond that, it looks to be 3.3V only; ask Sparkfun how popular 3.3V Arduinos are vs their 5V siblings.  Overall, I don’t find it terribly friendly to kit work.

TI is going to move a ton of these devkits, but I don’t see it developing into an ecosystem like the Arduino’s. Kitmakers are going to feel the “cheap cheap cheap!” pressure, and it’s going to be really hard to escape that.

(That said, I have a design for the “ProtoStation” already done. I just need to get my mitts on a copy of the board to double-check my schematic before I send it off to the board house. Hopefully people are willing to spend another $3~10 on their new ultra-cheap toys.)

* NB: TI hasn’t published application notes for that uC, nor a reference schematic in the datasheet, so my design estimate is ballpark, within a quarter or so.

Want to learn how to repair circuit boards?

Did you make a PCB, only to find out that the design is wrong?

Green wires to the rescue! “Green wires,” aka “patch wires,” are the fixups made after-the-fact, completing connections and adding components. It’s the last (and mostly hidden) step in circuit design: schematic, board, green wires. There’s a lot of art to green wiring, but you can learn the fundamentals in a couple of hours, hands-on.

Conveniently enough, I’ll be running a 2 hour, hands-on workshop on green wiring on Saturday, July 10th! The cost is $25, which includes an Arduino clone kit that needs several kinds of fixes. We’ll talk about diagnosing potential problems on a circuit board, then walk through techniques for fixing them on a kit I’m developing. At the end,
you’ll have new tricks for fixing boards, as well as a better understanding of the board design process (and a shield-compatible Arduino clone to play with).

This is a slightly advanced workshop, so you should be comfortable with a couple of things:

* soldering: we’re going to do a fair bit of this (building a kit)
* reading schematics: you should be able to read basic schematics

If you’d like to come, please let me know, so I know how many kits to bring. And, if you pay by PayPal before July 4, it’s only $20:

Register for the green wire workshop! (Workshop has happened, look for a re-run at a future date!)

What:

Green wire workshop (PCB fix-up)

When:

Saturday, July 10th, 1PM

Where:

Noisebridge
2169 Mission St (at 18th)
SF CA 94110

BART: 16th and Mission

Cost:

$20 before July 4, $25 thereafter (materials included)

Noisebridge is an open workspace, so the environment may be a bit chaotic.

10% of the money I collect will be donated to Noisebridge, to ensure we continue to have it as an excellent resource.

What we’ll cover:

* The construction of a PCB
* Identifying faults (shorts, opens, and oopsies)
* Basic strategies for dealing with the above
* Hands-on practice fixing each of the above

No one turned away for lack of funds. Drop me an email in advance, and we’ll work something out. I’d love to have you there!

I’m now selling my first kit! The Breaduino is a $10 Arduino clone you build from scratch. Unlike most kits, there’s no circuit board: you provide a breadboard (even the teensy half-length ones will work), and build your own Arduino from scratch.

I’m really excited about the prospects for this kit. It’s perfect for a classroom setting, which is a big deal to me. Any electronics classroom has everything you need to build this, and it can run off a 9V when completed, letting everyone start their kit up, instead of taking turns on the bench supply. More importantly, students can see exactly how it’s hooked up: it’s pretty darned simple. As an instructor, you can easily explain the purpose of every component during assembly, and still have a classroom of the things assembled in a half-hour session. I’d love it if these made their way into classrooms (email me for educational discounts). At $10/each, the Breaduino kit is also pretty easy in terms of materials fees. Students will also need a 9V clip ($0.10) and a breadboard ($8 for something nice at Adafruit), so, for $20 apiece, they can take home their handiwork.

It’s also great for those of us who work on Arduino-powered art pieces and gizmos. Dropping a Duemilanove ($30) into a project is a commitment, especially when the rest of it is made from free-to-you scavenged parts. This kit is designed for a breadboard, but it’s totally amenable to solder-down protoboard for permanent installation. You can do all your prototyping on a breadboard with a Breaduino, then transfer it exactly as-is to a protoboard. It’s also really small-footprint, so you can use a board only a fraction larger than the Atmega328 chip itself. The only way to get appreciably smaller is to go surface mount (but that kit’s a ways off). I’m hoping to do cheaper soon, too, by removing a few components from this kit.

Building the Breaduino kit has been interesting. It’s been almost entirely a matter of documentation: putting together an Arduino clone is fantastically straightforward. Between Atmel doing a fantastic job of making an easy-to-use microcontroller and the clear schematics from the Arduino team, it went together quickly. After that, there was a bit of work putting together a bill of materials, and a big order from Mouser. Then I had to document it. And make a video. And a website. And then redo a bunch of that, because it looked awful. Finally, all that work was done, and it came time to bag up kits. Oh, wait, I need a sticker design, and and and…

Happily, a lot of that work was in learning. I’ve now learned a lot, and will have a few more kits coming out soon: a 48-input analog input shield, another couple of different low-cost Arduino clones, and, eventually, the project that kicked all this off: a near-space ballooning shield. I’ve got a handful more ideas for things, too: a benchtop power supply with LCD readout powered by an Atmega, the ever-popular automatic bike lights, a plug-and-play relay board, an RFID appliance shield, an all-surface-mount Arduino clone… That said, I’d love more ideas. I’d love any kit suggestions people might have, leave a comment!

The iPad is hot. It’s a stellar product, with slick hardware and software. And Apple will make it better, much to their credit. Unfortunately, they’re making it a closed device: you must go through Apple to write software for the iPad, and forget about even replacing the battery yourself. It’s a sealed box, and Apple controls everything about it. They see this as key to keeping their (incredible) user experience today, but I wonder if they’ve thought about the longer-term implications. I believe that they’re depriving themselves of their lifeblood in ten years’ time. It’s not just the iPad, either: it’s the increasing prevalence hermetically sealed hardware and software. But I’m going to pick on Apple because they’ve done a total about-face from their origins.

Apple is putting a (relatively steep) barrier to entry on getting content on their devices. I understand why they think it’s important: to maintain that trademark slickness, they can’t let Just Anybody in. Considering that they built or purchased every component in their system, that’s their perogative.

But they’re shooting themselves in the foot. Not today, with all the rabid Free/Open Source fanboys; we’re a tiny drop in the bucket, even with the ripple effects of our righteous indignation. Instead, they’re crippling the next generation of creative programmer, or at least pushing them off to other platforms. Those creative types are the people who make Apple’s own products so great, and are the people who build innovative software on their platform.

My generation of programmers will talk about their first programming language with an acute nostalgia. Most of us learned to program using a language called BASIC, which teaches you all sorts of bad habits. It’s the programmatic equivalent of learning to drive in a car with half a steering wheel, a missing rear-view mirror, and no turn signals. But every platform back then came with BASIC, or had one easily available. Even if you didn’t have that, your middle school graphing calculator came with a BASIC. And that’s how we learned to think like a computer (or at least, as close as you can in BASIC).

From tweaking the BASIC programs we swapped with friends on floppies, we went on to build other creative things. We wrote text adventure games, graphical animations, and programs to work our algebra homework for us. BASIC opened up a new venue for creative expression, and we kept at it. Giving a kid a BASIC is like giving them pastels or tinkertoys: the initial products are rough and silly, but they’re forming a critical foundation for later development.

With new, hermetically sealed platforms, I fear we’re going to miss kids during their “critical period” for learning to speak programming languages. We’ll have a whole wave of programmers that didn’t get the tools to program until they were freshmen in college. Programmers who had that experience are working in the industry today, but they started at a great disadvantage, and it shows. They make great “engineers,” writing software to match a specification using standard tools they learned about in books. They are not, for the most part, the kinds of people who really innovate in the discipline. Would you expect exciting new paintings from someone who didn’t handle a paintbrush until they were nineteen? Or dynamic buildings from someone who hadn’t built so much as a pillow fort before college?

That’s what we’re forcing upon this generation of kids. We’re taking away their fingerpaint and their Lego, and I fear we will reap what we sow in a decade’s time. Apple and Microsoft are both pushing towards more closed platforms, and many vendors are on-board with the effort, or at least are complacent about it.

I’m especially disappointed with Apple, though: their first mass-produced computer booted up to a BASIC prompt.

You might remember muralizer, a mural drawing robot I was working on at Noisebridge earlier this year.  Things went awry, and the project never really achieved fruition.

I’m starting it back up again; more deatils over at its own blog: Muralizer Project Blog.  In particular, I’m trying to make ends meet for a few weeks with just Muralizer work.  To that end, I’ve started a pledge drive over at kickstarter: Muralizer kickstarter page.  This is something like a PBS pledge drive, with me handing out prizes for different pledge levels, with a big twist: if the funding goal isn’t met, no money changes hands.   This is great, but means that I need to be getting the community behind me.

So, if you’re reading this and can afford to kick in a few bucks to make a really cool open hardware project happen, please, pledge at kickstarter.  I’d really appreciate it, as would the community of artists who will benefit from a friendly kit version of this hardware.  Thanks in advance for your support!

Fair Use Reminder

A really nice Fair Use Reminder from the folks at Freedom For IP.  We need a copy of this on the wall at Noisebridge.

(via Serafina Kernberger)

Since I don’t remember when, I’ve kept a paper logbook next to my computers.  It’s my lab notebook, where I track what I work on each day, with tables of intermediate results and charts literally cut out of spreadsheet printouts and taped in.  This way, when I go into meetings, I just carry my notebook, and I have immediate access to the process I went through in a given tuning session, etc.  It’s most helpful when I’m coming back to something a week later: I can see what I’ve already tried, so I don’t wind up tuning in circles.  It’s second-most helpful when someone suggests pretty obvious refinements that didn’t pan out: “Shouldn’t we try inverting the score here, then doing this?” is answered with “If we do it that way, the recall goes down by 10% but we get a 0.5% improvement in precision, here’s the data.”  I love these notebooks (I keep nicer ones at home than I do at work, honestly), and find they’re really helpful for keeping me focused when working.  I’d highly recommend

These notebooks are obviously enough chock-full of proprietary information, so I can’t take them with me when I leave.  Therefore, they get handed off to some poor bastard who has to try and decipher my handwriting, process, etc.  It’s mostly a symbolic thing: “My time here is done; I leave these with you because I trust you to carry on what I was doing.”

Today, I handed off my notebooks for Aardvark (3 of ‘em) to my coworker Mike.  Tomorrow is my last day here; after that, I have a half-dozen little projects to chase down, as well as seeing how the world goes for a freelancing jack-of-all-trades.

Real World Haskell Chapter 3 is your introduction to the real syntax of Haskell programs.  It’s not entirely complete yet (you need modules and a few other things), but it’s enough to write one-purpose scripts, which is a huge step.

Again, there wasn’t all that much new to me in Chapter 3 here.  The important thing to takeaway was a review of the difference between data and type: data is struct, type is typedef (with type safety).  Other than that, the coverage of guards was nice, and the exercises were good for reinforcing knowledge and expanding horizons a little bit. Ending with the Graham scan algorithm is a little intense, but it’s significantly less evil than some of Knuth’s high-numbered problems.

However, in the exercises, be wary of number 4: there was a ++ operator introduced in the context of strings.  Don’t forget that it exists.  Number 5 is also a bit gnarly; I feel like they’ve totally screwwed the pooch on it.  If you don’t get it within 10 minutes, give up and read the comments on the website (or, if you know a bit about the performance of Lists in functional languages, just accept that your solution is O(n²)).