Mike Tsao geeks out.

Hypna Go Go Goes 3D

Wed, 30 May 2012 08:59:12 -0700

In my continuing quest for lucidity, I’ve had trouble figuring out exactly when my personal REM phases occur at night. Preliminary measurements and intuition suggest that they’re happening quite early — as early as two hours after I sleep. So it’s not surprising that the Hypna Go Go, using a naive time-based scheduling algorithm, doesn’t seem to be doing a good job of guessing the answer, either.

As an experiment, I’ve ordered an MMA8452Q accelerometer breakout board from SparkFun, and I’m going to build a new version of the circuit that starts the light programs when I’m not moving, which should be correlated with the hypotonia of REM sleep paralysis. The advantage of this approach versus, say, using an infrared receiver to measure eye movement, is that the board remains small and simple, without too many scary parts poking out near my eyes, and easy for me to sew into a relatively comfortable sleep mask.

New Project: Like A G35

Fri, 25 May 2012 08:54:00 -0700

Last year I took some good work by Robert Sun Quattlebaum and others and made an Arduino library that controls GE G35 Color Effects Christmas lights. For the 2011 season I whipped up a quick perfboard using a Teensy, and since then I’ve wanted to build a more permanent board that I might leave up year-round; after all, plenty of evenings call for fancy lighting. Why let Christmas have all the fun?

Thus, a few days ago I started my latest project: Like A G35. It isn’t much at the moment, but if I start prototyping now (in May), it ought to be ready to go by the time I want to deploy it (Halloween at the latest).

The circuit will be my first based on the ATmega32U4. I’ve worked on that chip quite a bit via Adafruit’s breakout board, but I’ve never gotten around to a build with it. It’ll be fairly simple:

Micro-USB socket for programming and power.
ISP6 header for initial programming (remember, the ‘32U4 isn’t available in DIP).
Three 3-position terminal blocks to support up to three strands of lights.
A second two-position terminal block for alternate power.
A beefy voltage regulator (at least 6 amps if I want to support three strands).
An infrared receiver to change programs.
A PCF8523 real-time clock with battery backup to display different programs depending on time of year.
Pinouts for whichever GPIO pins are left on the chip.

In all likelihood I’ll solder only the USB socket, the ‘32U4, and two of the terminal blocks, because I have only two strands on my house, I prefer to power directly through USB, and I won’t get around to any RTC or remote functionality. But in case other people want to build the board and use it for other purposes, it’ll be nice to have those other features optionally available.

RPio is assembled and (so far) working

Sun, 13 May 2012 09:03:07 -0700

I assembled one of the SeeedStudio boards and began testing. The power sections appear to work correctly, the project LEDs all behave as expected, and the TXB0108 I/Os are not surprising me (that’s a qualified statement because I haven’t yet run them all the way through their paces).

I haven’t yet tried the two I2C circuits. Once I’ve completed this testing, I’ll have done pretty much everything I can before getting access to a real board.

As you can see from this preassembly photo, I mistakenly ordered 0603 resistors rather than the 0805 size that the layout intended. But having assembled the board, I can say without hesitation that soldering 0603 parts onto 0805 pads is sheer delight. It’s like moving into a loft with no furniture yet; there’s just so much room!

Hypna Go Go Algorithm Adjusted

Fri, 11 May 2012 08:55:00 -0700

The Hypna Go Go recently woke me up three times in one night. I’ve adjusted the lighting algorithm to fade in gently, and hope this will help.

Update: Progress. I had a false awakening after this change, in which I took off my sleep mask and tried to shut off the HGG, but discovered the battery was getting weak. Then in real life my kids woke me up. I consider this to be progress because it was my first reaction to the lights where I didn’t wake up. Unfortunately, rather than realizing I was dreaming, I did what I usually do when the lights wake me up: I take off the mask and shut off the device.

OK Wake is done!

Fri, 11 May 2012 07:00:13 -0700

I ran through a full sequence Tuesday night and was happy with what I saw. So I’ve tagged the project FIRMWARE_WORKING_1_0_0, and after a morning or two to confirm that the actual devices are working, I’ll deliver one to my friend.

It’s fun to finish projects. The Hypna Go Go is a practical device that I use almost daily, and now OK Wake has the potential to help a friend and his family manage their morning routine. I feel a sense of accomplishment.

Next tasks: build an RPio (the boards arrived over the weekend, though still no Raspberry Pi on the horizon). And do one more hardware revision of the AVR Programmer. I also have a couple more quick projects in mind.

RPio prototypes are here

Thu, 10 May 2012 08:59:54 -0700

Now all I need is a Raspberry Pi!

OK Wake firmware, status report #2

Wed, 09 May 2012 09:01:26 -0700

Things are looking better.

I wrote a unit test suite that is buildable with regular GCC, so I was able to get the arithmetic routines written quickly without coaxing tiny LEDs into telling me the microcontroller’s entire internal state. This worked well. I didn’t have to stub or mock out the hardware, but I could see doing that for a more complex project.

I briefly dabbled in pure shift-based arithmetic (multiply by 205, shift right 11 times!) when I ran out of program space and took a hard look at the assembly with avr-objdump -S. This didn’t work out; doing mod 10 to convert from decimal to BCD was eye-crossing and approaching the size of the avr-libc mul/div libraries. Instead I took a different approach.

I hated the AVR310 reference I2C code for its size and seemingly needless complexity, so I replaced it with Peter Fleury’s awesomely tiny I2C Master library. I couldn’t believe that it worked perfectly on the first try. Since it uses plain GPIOs and doesn’t mess with the USI, I could even rework the circuit in the future to move the button/INT functionality to the ‘25’s INT0 pin, getting more precise pin-change interrupt events in the bargain.

This got me well under 0x700 bytes, so I could once again easily afford to use *, /, and % (I actually skipped %, preferring to multiply back the division result and subtract from the original value).

Code’s looking good and starting to feed solid.

OK Wake firmware, status report

Tue, 08 May 2012 08:53:56 -0700

I have the AVR and the PCF8523 communicating with each other, and the AVR is mostly able to manipulate its own EEPROM. Things are at least a couple bugfixes away from working end-to-end, though.

Things I Learned Recently

The RTC should be reset when the AVR starts up. It’s far too easy to leave it with sticky state that causes known-good code to misbehave. Fortunately, resetting leaves the time and alarms intact, so it’s nondestructive to do it regularly.
The ATtiny25 has frustrating support for I2C, a.k.a. TWI or two-wire mode. Yes, it has a USART that can do what I’ll call hardware-assisted bitbanging of I2C, but the code to actually do that bitbanging uses up lots of program space. The combination of 8-pin AVR, I2C, and small program space is challenging. I think I can do it, but it might be smarter to switch to an ATtiny85 during development so I can add more diagnostics while debugging.
I was spending a lot of time trying to distinguish different reasons why my single interrupt was firing (button-press, /INT low for second interrupt or alarm) without communicating with the ‘8523. The reason for the no-communication part was that the ‘8523 was unavailable within the interrupt (interrupts disabled = no I2C). This was a losing proposition. It was much easier to have the interrupt wake me up, exit the interrupt without doing any work, then ask the ‘8523 via SF/AF whether it wanted me awake. If yes, deal with that. If no, then it must have been the button. This approach is much more solid, and it’s what the ‘8523 designers intended.
Doing development with a coin-cell-powered circuit means that your code might start acting weird if the coin cell approaches 1.8V. Better to power via a reliable supply during development.
Power pins and test points would have been a godsend on this ridiculously small board. I should have added a header for V+, GND, /INT, SDA, and SCL. Nice big 0.1”-spaced pins to attach logic probes.
Binary-coded decimal is a pain to work with. This is the ‘8523’s native number format. I am currently staying in packed BCD for all operations, which neutralizes the annoyance, except for doing time math, where I have to convert back to regular decimal. I need to think harder about whether there’s a clever way to multiply/divide by 60 in native packed BCD.

avr-gcc and static initializers

Mon, 07 May 2012 09:01:51 -0700

In the avr-gcc FAQ, the question “Shouldn’t I initialize all my variables?” gives a hint why your nonzero static initializers aren’t working:

[G]lobal and static variables that have an initializer go into the .data section of the file.

I had been seeing static variables without a declared assignment correctly initialized to zero, but any nonzero initialization didn’t seem to be doing anything. But reading the FAQ led me to examine my makefile, where I found this interesting section:

%.hex : main.obj $(OBJ2HEX) -j .text -O ihex $< $@

Aha! So avr-gcc was likely putting the initialized variables into .data, but I was omitting that section when generating the Intel hexfile. Adding another -j section for .data fixed it.

How I memorized π to more than 60 places

Fri, 04 May 2012 10:26:01 -0700

In high school I memorized pi to 18 places. It was easy; when you’re 15 years old you can achieve any mental feat imaginable. Knowing the number to excessive precision was useful when I was programming games or art projects, and when doing geometry homework, I would take a 10-second doodle break by writing the number out in the margin. Like the home phone number my mom made us memorize when we were kids (408-722-2997), the number’s now burned forever in my brain. 3.14159265358979323.

I never tried memorizing any further, because (a) it seemed pointless, and (b) I figured it was one of those youthful talents lost to the sands of time. But over the past couple months, I have memorized pi to over 60 places. It wasn’t hard to do, and here’s how I did it.

First, of course, I started with the first 18 digits and built on that. Over the years, while reciting the sequence to myself, I’ve developed a bit of a cadence and rhythm in the delivery. It’s not quite a song, but it becomes effortless to recall it the same way I can remember song lyrics. So I tried to continue to do that.

Second, I picked small chunks of digits. I know nobody remembers phone numbers anymore, but I’ve heard that the inventors of phone numbers put the dash in between the groups of numbers to turn it from the challenge of remembering seven (or ten) individual numbers into a simpler task of memorizing two (or three) groups of numbers. For me, groups of six seem to work well, because I can recite the six as di-di-di (pause) di-di-di (pause), and it stays in a 4/4 time signature (that’s a musical term; remember that I find it easier if they’re recited according to a rhythm).

Third, I practice at least a couple times a week. I’ll recite it to myself when I’m waiting in line for lunch or stuck in traffic. I can’t yet say that this will lead to permanent recall (in the way that I’m confident I’d remember the first 18 digits even if I didn’t think about them for five years), but I haven’t noticed any dropoff yet.

That’s pretty much it. I have attached some mnemonics to specific sequences, which I’ll describe below, but those feel more like excess mental baggage that my brain has stored away, rather than a recall aid. Or maybe not; I really can’t tell.

Here’s the story of the individual digits:

3.14159: everyone knows this.
265358: the “65,” “35” part is starting to establish a rhythm.
979323: this is two groups of 3-digit palindromes, and the 323 is a Mazda car model, which reminds me of the Mazda 626, which is the car I was in when my dad decided the red traffic light must be broken and proceeded to almost kill me when we got T-boned in the intersection by a car that had the green.
846264: again a palindrome inside this sequence, and 264 reminds me of the h.264 codec.
338327: so many threes. For the second half, three times nine is 27, and because my brain has accumulated the two threes from the first half, it’s already primed to spit out 27 as the product of 3 x 3 x 3.
950288: makes no sense to me (other than that 288 = 2 x 12 x 12, which is cool), but it’s memorable mostly because it’s a nonsense sequence.
419716: 419 is the number associated with those I AM HEIR TO THRONE AND NEED YOUR HELP spam mails (it’s some reference to a penal code or something like that), and the 716 forms almost the same shape if you’re dialing it on a phone keypad.
939937: this is weird because it has so many nines in it, and when dialed on a keypad it reminds me of a person on a trampoline jumping back and forth and then accidentally flying off it.
510582: 510 is an area code in the San Francisco Bay Area, and the 582 starts with the same digit.
097494: makes no sense at all. I need to explicitly remember that after the 510 sequence, the next sequence starts with a zero. The 494 is easier to remember than the 097 because it’s a palindrome.
459230: this is the most recent sequence I’ve memorized, and I don’t have it down yet. 459 is dangerously close to the palindromic displacement of the old Chevy 454 engine (dangerously because at the moment I can’t easily remember the 9), and 230 is a protective provision in the otherwise awful 1996 Communications Decency Act U.S. legislation.

So that’s actually getting close to 70 places, and as you can see there’s quite a bit of mnemonic baggage that my brain has conjured up on its own. I will probably keep memorizing more digits because it beats watching TV as far as pointless activities go. However, the number of digits memorized at this point is getting into weirdland, so I might take a break from new digits for a while and just stick with the sixty-something as a party trick.

Don't make this mistake with Arduino streaming APIs

Fri, 04 May 2012 08:54:48 -0700

This happened to me. Don’t let it happen to you.

Write a constant somewhere, like Wire.write(0x06). In my case, this was sending an address to an I2C chip, but it could be Serial.write() or something else like that.
Confirm everything’s working great.
Later on, change to Wire.write(0x00).
Get a compile error about how the function signature is now ambiguous because zero can be any of multiple types.
Be specific: Wire.write(0x00, HEX).
Confirm everything’s working great.
Now copy your earlier code somewhere else: Wire.write(0x04, HEX).
Your I2C device begins emitting lethal radiation focused on nearby kittens.

The mistake started with step 4 (misinterpreting the compile error) and its fate was sealed with step 5. The problem is that the Arduino’s print/println methods are slightly different in that they take an optional format argument as the second parameter if the first doesn’t fit a single function signature. The streaming APIs, on the other hand, take a pointer and a length. So my Wire.write(0, HEX) was actually Wire.write(address 0, 16 bytes). In Step 6 I just got lucky that whatever I wrote to the device didn’t change behavior much, but Step 7 my luck ran out.

TL;DR: print takes a format specifier. Streaming libraries take a length. If you mix them up, it still builds.

OK Wake as its own breakout board

Thu, 03 May 2012 09:13:07 -0700

I am not usually this smart. I was fretting about how to get accessible pinouts to the tiny SOIC-8 PCF8523 while developing the OK Wake firmware on an Arduino. I thought about dead-bug wires, or picking up an SOIC breakout board from a local store, or doing something ugly with perfboard. I briefly explored repurposing an old unpopulated PCB, like maybe the third Hypna Go Go PCB from Laen, which uses an SOIC-8 for its ATtiny13a.

Then I realized that the OK Wake itself was the perfect board! Just connect the ATtiny socket’s pins to the corresponding pins on the big brother Arduino. That’s what I did, and it’s working very nicely. And as a bonus, I didn’t have to sacrifice any PCBs or extra PCF8523s.

Kind of obvious in retrospect. But in mental cycles expended, I definitely earned it.

[Update from a couple hours later] I’ve successfully done the following:

Using the Arduino’s Wire I2C library, read the seconds from the ‘8523 and confirmed that they increment properly.
Turned off the CLKOUT default settings, which were messing up /INT.
Set SIE, which enables the once-a-second interrupt on /INT.
Configured TAM to pulse the /INT interrupt so I don’t have to clear it.
Confirmed with my logic analyzer that the pulse is indeed 1/64 seconds long.
Got the Arduino firing an interrupt routine when /INT goes active.
Confirmed that the button and the ‘8532 /INT signal don’t interfere with each other.

In other words, unless the ATtiny is weirdly different from the ‘328, then the circuit is in perfect working order.

First two OK Wake boards. I assembled them and wrote a quickie...

Wed, 02 May 2012 08:07:42 -0700

First two OK Wake boards. I assembled them and wrote a quickie program to test that everything was wired up properly. I haven’t yet run the PCF8523 real-time clock through its paces, but everything else is working properly.

This board is going to require some nontrivial firmware, and I haven’t ever worked with I2C (or the generic-brand TWI, or two-wire interface) on an AVR, which means this is going to be a significant opportunity to learn. Because I didn’t have the space for an ISP header, I’ll probably develop most of the firmware on an Arduino or Adafruit ‘32u4 breakout board to avoid having to constantly unplug the ATtiny25. That will speed up development time, I hope.

I did make one mistake in this circuit. I had a half-baked idea that a 10uF capacitor could power the RTC during battery changes. I have absolutely no basis for my belief that that capacitor is large enough to power the RTC during the 30 seconds it’d take to change the battery, but even if it were, I neglected to put a diode in the circuit to stop the ATtiny from quickly draining the capacitor. This probably means that changing the battery will be disruptive. Fortunately, I expect the lifetime of the battery to exceed the useful lifetime of the board (remember, this is for a friend’s children who aren’t yet old enough to read a clock but are likely to respect a color-coded admonition to stay in bed, and I’m sure that in a year they’ll have grown out of that phase).

Hypna Go Go Scares the Crap Out of Me

Tue, 01 May 2012 08:51:01 -0700

A couple nights ago I had my first Hypna Go Go-influenced dream. I don’t remember what had been happening in the dream, but suddenly a bright drag-race-Christmas-tree-style pole of lights appeared right in front of me. I realized that this was my signal that I was dreaming. Unfortunately, I couldn’t shake my dream-world concern why the big red lights were flashing; was it an ambulance? Was it a traffic jam or an accident? Were my family members hurt? The next couple moments of the dream were vague and unpleasant, and I woke up.

I’m not going to change anything with the device for now. Yes, the lights are probably a little too bright, but having replayed the light-pole event in my mind several times while awake, I believe I can train myself so that next time it won’t be a distressing experience.

Incidentally, I’m getting pretty good at dream recall. I’ve written down about ten dreams, and have been aware that I’ve forgotten nearly as many more. This is much better than a few weeks ago, when it seemed that I had no dreams at all. And lately I’ve been having a sense of general well-being about the world, which I would expect given that my dreams are often about seeing old friends and being in interesting places. Or maybe it’s because it’s Spring in my part of the world.

The first PCB version of the Hypna Go Go works just fine!

Mon, 30 Apr 2012 19:33:50 -0700

The first PCB version of the Hypna Go Go works just fine!

Awesome work on JTAGWhisperer! Been reading all about this project and ran into a hitch. First my setup... I'm using an Arduino Duemilanove with 4 channel bidirectional logic level converter and trying to program my Taio xilinx Coolrunner II (XC2C64A). I get the ready to send output, and then confirmation that the device is ready. After that it freezes after sending 32 bytes, no matter what xsvf I try and program to the CPLD. TDO is high at 3.3v on the CPLD, but just hangs. Any thoughts?

Sun, 29 Apr 2012 09:47:22 -0700

When I was debugging this thing, the Arduino serial connection (which uses software flow control, a.k.a. no flow control) was getting confused or falling behind. Try setting both sides to a very low bitrate (like 9600 or 2400).

Do you have a logic analyzer? That was invaluable in isolating problems.

Are you sure that the target board doesn’t have any jumper/power requirements? My board needed two power sources: one for the core, and one for the I/O.

The smallest possible XSVF is one asking for the device ID and ending. That one’s also attractive because it doesn’t involve writing (which can be very finicky about voltage levels).

Be sure your XSVFs are generated specifically for your chip. The ones in the repo are for a XC9572XL, which is incompatible.

That’s all I can think of right now.

Making more geeks, one geek at a time

Sun, 29 Apr 2012 09:05:57 -0700

Please pardon a slightly off-topic post. This isn’t about electronics, but it’s about making more people who might make electronics, so it’s almost relevant.

Saturday afternoon my seven-year-old son asked if I’d let him play Quake 3 on my desktop computer. I said sure and walked him through bringing up the Ubuntu Unity menu, typing in “ioquake,” and so on, until he’d started a multiplayer game populated with several bot enemies. All was well and I returned to fiddling with Twilio.

Then came the Tech Support call: “DAD!!!” My son had navigated down into some odd menu I’d never seen, and both of us needed some time to figure out what was going on. We hit escape, got our bearings, and he was back manufacturing gibs once again. I told him to stick to the main options in the menu.

“OK, Dad.” And back to Twilio.

“DAD!!!”

This time he’d done something kind of interesting. He’d opened the Quake console and had gotten into some state that seemed unrecoverable except for quitting. I was about to repeat my “stick to the main” admonition, except this time phrased as a “because I’m Dad — now it’s a rule — disobedience forbidden — on pain of punishment” kind of parental edict.

Fortunately, I caught myself, just before the words left my mouth. My son was doing exactly what I used to do when I was learning computers. He was exploring every path in the UI, seeing what would happen, poking the box. This was hacking. This was the satisfaction of curiosity, the development of proficiency, the beginning of true understanding. This was my son being a geek.

My irritation subsided. Awe replaced it. I stepped back, literally and figuratively. I nudged him a bit to get him unstuck, as he’d asked me to, but I let him keep exploring the real game that he wanted to play — the user interface of this shoot ‘em up.

Hi Mike, This is really cool (JTAG Whisperer). I am really interested in trying this out with a Teensy 2, wwwpjrccom. I have a couple on hand right now. Those will run "serial" at about 1.1 MByte/sec. Jack also sent me a C\Wing board... so I can try programming it. Question: the Python side of things. What do I need to do to set up Python, where is your code, etc. I have never done Python. I do like communicationg with Arduino thru Microsoft's free C# Express. That might be another option...

Sat, 28 Apr 2012 19:32:44 -0700

Python’s at www.python.org. The blog links to the GitHub project, and it’s the top hit on Google for “jtag whisperer.” If you have trouble running it, let me know. I’m not going to be the best authority on setting up Python, but there are (probably) a zillion howtos out there. Good luck and let me know how it goes!

Where to buy? ... i want it nowwwwww!

Sat, 28 Apr 2012 19:30:51 -0700

Hi there, thanks for writing. Which project are you talking about? I’m working on about a half-dozen right now.

Hello World on STM32F4 Discovery

Wed, 25 Apr 2012 09:01:54 -0700

I got a blinking LED (the embedded Hello World) on my STM32F4 Discovery board. It probably would have been easy to do, except that I was on OS X. Here are the steps I took:

Tried a bunch of stuff.
Switch to Linux.
Tried a bunch more stuff.
Took a break.
Found this extremely correct page, which helped me build a real ARM toolchain.
Built stlink.
Built some of the stlink samples.
Got gdb going with the stlink gdbserver.
Stepped through some code in RAM (not flashed).
Using the stlink flash utility, flashed code I built to the board. Unplugged it and plugged it back in to confirm the code was still there.
Flashed back the “Discovery” sample shipped with the board.

From this adventure I can confirm that summon-arm-toolchain does work if you switch to the dev branch, and that the ARM version of gdb really and truly allows interactive debugging on this tiny little dev board. Quite a step up from the AT90S4433 and early avr-gcc toolchain that I first started hacking on back in 2002.