Jonathan Thomson's web journal

Halloween 2016 – Jackpot October 31, 2016

Filed under: Electronics,Halloween — jethomson @ 9:17 pm


I attached a nylon belt to a toy slot machine coin bank so I could hang it around my neck, and created a music box using an ATtiny861 to play sound effects. The music box uses three differently colored gumdrop LEDs that hover over mini push button switches, so that pushing down an LED results in a push button switch being depressed. The LEDs were made to spring back by bending their leads at a right angle, running them through heat shrink, and gluing the heat shrink to the board (see the picture below). If the player hit the jackpot I pressed the green button to play winning sound effects. If a jackpot wasn’t hit the red button was pressed, and a losing sound effect was played. The orange button played Halloween themed sound clips. A schematic can be found by following the link in the found in the GitHub repo for the code.



Music Box Code on GitHub


Halloween 2014 – Jack Skellington October 31, 2014

Filed under: Electronics,Halloween — jethomson @ 8:38 pm

First, I printed out two copies of Jack Skellington’s divided-up face in yellow on a few sheets of paper. Then I put a little bubble wrap to act as a diffuser around a bunch of flickering yellow LEDs. The LEDs were powered by CR2032 coin cells with three LEDs per cell. Finally I sandwiched the LEDs between each copy of a part of Jack’s face, and attached these to an orange shirt with double sided tape.





PDF of Jack’s face divided into four pages

Source for yellow flickering LEDs


Level Headed – EL Wire Decorated Headphones July 5, 2013

Filed under: Electronics — jethomson @ 12:25 am


I decorated a pair of headphones with electroluminescent wires (EL wire) that react to the music you’re listening to. I modified an inverter taken from a graphical equalizer T-shirt to respond to an audio signal from my mp3 player instead of sound. Here’s a link to the instructable.


How to use the TSL2561 May 22, 2012

Filed under: Electronics,Spectrometer — jethomson @ 2:07 am

The TSL2561 is a light-to-digital converter from TAOS. It senses light intensity and transforms its measurement into a digital output that is transferred over I2C or SMB. If you are familiar with the TSL230R light sensors, you shouldn’t have much trouble working with TSL2561s, but there are a few important differences. The TSL230R outputs its data as a pulse train, so a microcontroller with frequency counting code is required to read the sensor’s output. The TSL2561 outputs its data directly over I2C or SMB, so the sensor’s output is simply read from the bus. The TSL230R is controlled by bringing purpose specific pins high or low. The TSL2561 is controlled by writing data to it over the bus. The TSL230R is available in a breadboardable package and runs at 5V. The TSL2561 needs an adapter board for breadboarding and it’s power supply must not exceed 3.3V. The TSL2561 also has a second diode specifically for sensing infrared.

Since the TSL2561 is so similar to the TSL230R in theory, I’ll only be writing one condensed article for the TSL2561. Please refer to the series of article of the TSL230R for a more in-depth explanation of how to acquire and process data from these sensors.


Serial Control
TSL2561_DAQ.ino (view online) enables serial control of the TSL2561 via a simple serial protocol between the host computer and Arduino. It allows the user to set the number of output samples, adjust the TSL2561’s sensitivity and integration time, and switch power to a light source. The Arduino IDE has a built in serial monitor, which you can use for testing serial commands. However, Tod E. Kurt’s arduino-serial is smaller and has more functionality.

The command:
./arduino-serial -b 9600 -p /dev/ttyUSB0 -d 3000 -s s016 -d 100 -s i101 -d 100 -s l111 -d 100 -s t005 -d 10000 -r -d 500 -r -d 500 -r -d 500 -r -d 500 -r -d 500 -r -d 100 -s l000

Outputs one read for each -r:
read: 697

read: 697

read: 696

read: 697

read: 696

read: EOT

This command waits three seconds for the bootloader to load the program (-d 3000) then it tells the program to set the sensitivity to 16x (s016), the integration time to 101 ms (i101), turn the light on (l111), and transmit five samples (t005). The command then waits 10 seconds for the buffer to fill (-d 10000), reads five samples (-r -d 500 repeated five times), and finally turns the light off. The blank lines in the output are from the line feed (i.e. \n) printed after each number. The uc code uses Serial.print('\n') instead of Serial.println() and the string “EOT” so that it can communicate with code written for GNU Octave and MATLAB.


Data Acquisition Scripts
The archive contains the m-files (view online: get_data, save_data, serial_open) necessary for controlling the TSL2561 within GNU Octave and MATLAB and reading the counts output from the ATmega uc.


Spectral Responsivity

The spectral responsivity for the Channel 0 diode when the gain is 16x, the integration time is 101 ms, Vdd = 3V, and Ta = 25°C is saved in Re2561.mat in the essential_data_sets folder within the archive


Converting Counts to Irradiance
With Re(λ) and a model of the spectral content of the light source irradiating the photodiode array we can calculate the spectral irradiance and total irradiance of the light source more accurately than in the simplistic case of assuming all the light source’s photons are 640 nm in wavelength.

For example, if we model a red LED with a peak wavelength at 640 nm and a full width at half maximum (FWHM) of 34 nm with MATLAB like so:

   % mathematically model lamp's spectrum as a gaussian curve with a peak 
   % wavelength at 640 nm and full width at half maximum of 34 nm
   e = exp(1);
   func_lamp = @(mu, FWHM) e.^(-2.7726*((lambda_Re-mu)/FWHM).^2);
   X = func_lamp(640, 2*17);  % [uW/(nm*cm^2)]

Then the output counts, cX, that would result if X irradiated the photodiode array can be calculated thusly:


However, cX is not the actual output counts of the TSL2561 because X is only a model of the shape of the light’s spectrum and lacks radiometric calibration. Since we can measure counts, finding the proper radiometric calibration multiplier for X is as simple as dividing counts/cX.


Therefore, a good approximation of the radiometrically calibrated spectral irradiance of the light source should be:


and the total irradiance is:



Newark gave me a TSL2561T light to digital converter from TAOS to evaluate as part of their product road testing program.

Thanks go out to ladyada for providing a library and basic example for working with the TSL2561.


Using a Wii Nunchuk as an Earthquake Sensor May 16, 2012

Filed under: Electronics,QCN — jethomson @ 9:57 pm



This article explores the suitability of a Wii nunchuk based USB accelerometer as an earthquake sensor for the Quake-Catcher Network (QCN) project. It examines the nunchuk over several metrics: precision and range, frequency response, total cost and availability.

The Quake-Catcher Network is a collaborative initiative for developing the world’s largest, low-cost strong-motion seismic network by utilizing sensors in and attached to internet-connected computers. With your help, the Quake-Catcher Network can provide better understanding of earthquakes, give early warning to schools, emergency response systems, and others. The Quake-Catcher Network also provides educational software designed to help teach about earthquakes and earthquake hazards.

Range and Precision
QCN supports a few different USB accelerometers. The most basic one is the JoyWarrior24F8 (JW24F8), which is a 3 axis accelerometer with 10 bits of precision and a measurement range of +-2g, +-4g, or +-8g. QCN uses the +-2g range. According to WiiBrew, the Wii nunchuk’s accelerometer also has 10 bits of precision over a range of +-2g. Therefore, the nunchuk meets the first criteria for evaluating its suitability as a QCN sensor.

Data Comparison
I don’t have access to a shake table so I’m unable to directly evaluate the frequency response of the nunchuk based USB accelerometer. However, QCN did provide me with a JoyWarrior24F8 USB accelerometer for comparison. Since the frequency response of the JoyWarrior24F8 was already deemed suitable by Prof. Cochran for QCN, I simply had to attach the JoyWarrior24F8 and the nunchuk to the same substrate, shake them by hand at various frequencies while recording data from both sensors simultaneously, and compare the Fourier transform of the nunchuk’s data to the transform of the JW24F8’s data.

Here are comparisons of an official (i.e. STMicroelectronics accelerometer) nunchuk to the JW24F8. The microcontroller code used was and the plots were made using the Octave scripts found in the code section below.


Accelerometer X-axis data comparison
Time domain plots:


Frequency domain plots:


Accelerometer Y-axis data comparison
Time domain plots:


Frequency domain plots:


Accelerometer Z-axis data comparison
Time domain plots:


Frequency domain plots


The STMicroelectronics based nunchuk appears to have a response that is very similar to the JW24F8’s response. It should be noted that I was shaking the accelerometers by hand so I don’t think I covered the entire range of frequencies of interest.

Unfortunately, there are fake (i.e. 6331 accelerometers) nunchuks that are unsuitable earthquake sensors because their accelerometer data has stuck bits. Even worse, it can be very difficult to impossible to tell if a nunchuk is official by external examination only.

The nunchuk uses I2C to transfer its data. Therefore, a microcontroller that supports USB and I2C is required to read the data from the nunchuk, filter it, and pass it to the host computer. Three different microcontrollers were evaluated: an ATmega32U2 board that supports hard USB and soft I2C, an ATmega328P with V-USB that supports soft USB and hard I2C, and an ATmega32U4 (teensy) that supports hard USB and hard I2C. The ATmega32U2 only works with 6331 based nunchuks and only at 100 kHz. The ATmega328P works with both STMicroelectronics and 6331 based nunchuks, but the two-wire interface (TWI) eventually locks up for an unknown reason. The ATmega32U4 works with both types of nunchuks tested and with no crashes observed over a two-week period. The STMicroelectronics nunchuk works at 100 and 200 kHz with hard I2C only. The 6331 based nunchuk works at 100, 200, and 400 kHz when hard I2C is used.

A Quake Catcher Kit from Saelig is $42.25 with about $12 for shipping to a U.S. residence, for a total of $54.25.

A Teensy with a 3.3V regulator and shipping costs about $22. A genuine, official nunchuk is approximately $20 shipped. A nunchuk extension cable from eBay is around $4.50. For a total price of $46.50. However, the cost of a proper mount for the nunchuk as well as the labor cost of assembly has not been included. Therefore, I believe that Quake Catcher Kit is most likely a better deal for your time and money.

All of the code in one GitHub repo.

_Microcontroller code_
The output resulting from microcontroller code that didn’t filter the accelerometer data was the most similar to the output of the JW24F8. Code that filters the accelerometer data with Chebyshev and moving-average filters is included for comparison purposes and because I’d already written it.

This code is for research purposes only; it uses an Atmel USB VID/PID pair for LUFA demos only. This code doesn’t work with QCN because the QCN software checks the joystick’s name to make sure it’s a JoyWarrior. This code can be easily made to work with QCN by modifying its USB descriptors, which I’ve done, but I won’t be releasing this code since it uses Code Mercenaries’s VID/PID. The code also checks the connected controller’s identification bytes to make sure its a genuine Wii nunchuk. It doesn’t work with fake nunchuks.

Wii Nunchuk quake sensor code for teensy (no filter)

Wii Nunchuk quake sensor code for teensy (moving average)

Wii Nunchuk quake sensor code for teensy (chebyshev)

_Host code_
Joystick Accelerometer Data Acquisition code for Linux

Octave plotting scripts


Fake Wii Nunchuks with a 6331 Accelerometer April 29, 2012

Filed under: Electronics,QCN — jethomson @ 12:45 am

While evaluating the suitability of a Wii nunchuk as an earthquake sensor (article not yet published), I discovered a few things about non-official nunchuks that use an accelerometer with the markings 6331 over QS***, where the asterisks stand in for a three letter code. This website (translated PDF) says these accelerometers are MMA6331L chips, but I’m not certain if they are genuine Freescale parts. The 6331 nunchuks don’t behave the same as the original nunchuks, which use an STMicroelectronics’ accelerometer. The 6331 nunchuks differ from the original in two important ways.

First, the 6331 based nunchuks don’t encrypt their data whether they are initialized using the old or the new method. This is important because there is a lot of microcontroller code on the web for reading data from a nunchuk that uses the old initialization method and decrypts the nunchuk data. Using this code on a 6331 based nunchuk will result in mangled data caused by incorrectly applying the decryption routine on unencrypted data. The solution is to use the new initialization method. This method causes an STMicroelectronics based nunchuk to output unencrypted data. Since the 6331 based nunchuks output unencrypted data no matter the initialization method, it’s better to use the new method without a decryption routine so your code will support both types of nunchuks.


    void nunchuck_init_old ()


    void nunchuck_init_new ()


Second, the accelerometer data in 6331 based nunchuks have some bits that are permanently fixed (i.e. stuck at 0 or 1). Bit 0 of byte 2 is always zero, bit 0 of byte 3 is always one, and bit 0 of byte 4 is always zero. Bits 3, 4, and 5 of byte 5 are also stuck at zero.

    Table 1
              7   6   5   4     3   2   1   0
    byte 2  | x | x | x | x | | x | x | x | 0 |
    byte 3  | y | y | y | y | | y | y | y | 1 |
    byte 4  | z | z | z | z | | z | z | z | 0 |
    byte 5  | z | z | 0 | 0 | | 0 | x | b | b |

Each axis of accelerometer data is represented by 10 bits with the 2 least significant bits of each axis stuffed in byte 5. When bytes 2 through 4 are transformed into accelerometer axis data, Table 1 can be rearranged to get Table 2.

    Table 2
                                      9   8   7   6   5   4   3   2   1   0
    x always zero                   | x | x | x | x | x | x | x | 0 | 0 | x |
    y always one, y always zero     | y | y | y | y | y | y | y | 1 | 0 | 0 |
    z always zero                   | z | z | z | z | z | z | z | 0 | z | z |


I have no idea why the accelerometer data in 6331 based nunchuks have some bits stuck like this. My first guess was that it had something to do with the Wii Motion Plus’s passthrough mode. The Wii Motion Plus (WM+) has a passthrough mode that interleaves nunchuk data with motion plus data. The WM+ discards some of the nunchuk’s LSBs to make room for bookkeeping bits. So I thought that since newer Wiimote’s include WM+ maybe the 6331 nunchuks don’t bother with the bits that will be discarded anyway. However, the bits discarded by the WM+ don’t match up with the fixed bits of the 6331 based nunchuks.


Identifying a 6331 based nunchuk
Unfortunately these fake nunchuks aren’t as easy to avoid as one might think. A nunchuk I purchased off of Amazon, which was advertised as official and looks genuine, has the same 6331 accelerometer and board as an obviously fake nunchuk I bought on eBay. The one I bought from amazon has a rubberized joystick, triwing screws, and the Nintendo logo.

There are a few ways to tell if your nunchuk is 6331 based. The most thorough method is to open the nunchuk and look for an accelerometer on the side of the board opposite the joystick with the markings 6331 over QS***, where the asterisks stand in for a three letter code. Another method is to use a program that performs the old initialization method and decrypts the data. When the joystick is centered the x-axis for the joystick (not the accelerometer) should be around 128. If the x-axis reads around 174 then the decryption algorithm has mangled unencrypted data. The decryption algorithm is (x xor 0x17) + 0x17 or in decimal (x xor 23) + 23. Therefore, (128 xor 23) + 23 = 174.


The STMicroelectronics accelerometer inside an official nunchuk. The official nunchuk also has a shielded cable.


Inside an fake/knock-off nunchuk purchased on eBay.


The board of a nunchuk that looks official from the outside but is actually fake. Notice that the EEPROM spot populated. The pinout of the 6331 as seen on the fake nunchuk’s board appears to agree with the datasheet except for one strange exception. The nunchuk is a three axis device, but the datasheet says the MMA6331L only measures x and y axis data. Pin 4 of the datasheet says it has no internal connection but on the board pin 4 has a trace that is connected to a filter capacitor and the microcontroller just like pins 2 and 3, which are the x-axis and y-axis data pins! It should also be noted that the MMA6331L’s minimum range is +-4g, where the STMicroelectronic’s nunchuk measures acceleration over the range +-2g.


Final Thoughts
If you have any information to share, please leave a comment below. I’m particularly interested to hear why 6331 based nunchuks have some of the accelerometer data bits stuck or how to unstick them. I’d also really like to hear what sort of accelerometers are being used in the nunchuks that come packaged with the newest Wiis.


Instructables January 25, 2012

Filed under: Electronics — jethomson @ 12:32 am

Here are links to a couple of instructables I recently finished.


Ceiling Fan Pull Chain Nightlight


Musically Animated Gift Box