Continue reading »]]> The setTimeout function allows you to delay the execution of code.  The setTimeout function works by specifying a string of code followed by the delay in milliseconds.  For example:

setTimeout(“alert(‘timeout!’)”, 1000)

The code above will display an alert box that says “timeout!” after 1 second (1000 milliseconds).  Because setTimeout uses strings of text that it tries to execute later, things don’t always work as expected.  Consider the following example:

var test = function() { var obj1 = new Object(); obj1["key"] = “value”; setTimeout(‘alert(obj1["key"])’, 1000); }

The code above defines a function called test.  The function creates a new object, sets the attribute “key” to “value”, and calls setTimeout to display an alert with the value of key 1 second later.  However, calling this function will result in a run-time error because obj1 is outside the scope when the alert function is executed.  To fix this, the code must be written differently:

var test = function() { var obj1 = new Object(); obj1["key"] = “value”; setTimeout(“alert(\”"+obj1["key"]+”\”)”, 1000); }

This code works as expected because the value of key is included directly in the string.  The code does not attempt to reference obj1 later.  But, let’s say you want to pass an entire object to some function.  Simply convert the object to JSON.  For example:

var test = function() { var obj1 = new Object(); obj1["key"] = “value”; setTimeout(“some_function(“+JSON.stringify(obj1)+”)”, 1000); }

Continue reading »]]>

Using my headphones with my computer is frustrating.  Whenever I want to use my headphones, I have to move my computer so I can access the back panel, unplug my computer speakers, and plug-in my headphones.  Okay, maybe it isn’t that difficult, but it should be easier.  How about a device that allows you to select between headphones or computer speakers?

Solution

After some careful thought, I realized such a device could be implemented using three 3.5mm jacks and one dual-pole dual-throw (DPDT) switch (see the schematic below).

As you can see, the DPDT switch simply selects whether the input is connected to the headphones or the computer speakers.

Other Possibilities

A similar device can be implemented using two dual-pole single-throw (DPST) switches.  This would allow the user to select headphones, computer speakers, or both.  A much more sophisticated implementation might include operational amplifiers allowing the user to adjust the gain on each output.

Continue reading »]]> This brief tutorial demonstrates how to create projects for the AVR using AVR-GCC.  This tutorial assumes that you are using Ubuntu for your development environment.  This tutorial also assumes that you have already installed AVRDUDE.  Also, you should have a development board with at least one button and one LED.  In my case, the button is active low.

1. Install AVR-GCC:

$ sudo apt-get install gcc-avr
$ sudo apt-get install avr-libc

2. Create a new directory for your project, let’s call it blink:

$ mkdir blink
$ cd blink

3. Download the template makefile:

$ wget http://electrons.psychogenic.com/articles/Makefile.tpl
$ mv Makefile.tpl Makefile

4. Copy the template makefile to your Templates folder if desired:

$ cp Makefile ~/Templates/avr-makefile

5. Modify the configuration section of the makefile.  This is fairly easy thanks to the helpful comments included in the makefile.  I used the following configuration:

MCU=atmega128
PROGRAMMER_MCU=m128
PROJECTNAME=blink
PRJSRC=blink.c
INC=
LIBS=
OPTLEVEL=0
AVRDUDE_PROGRAMMERID=dragon_jtag
AVRDUDE_PORT=usb

6. Get blink.c:

$ wget http://www.krisbarrett.com/wp-content/uploads/2009/09/blink.c

7. Modify the #defines so that they correspond to the connections on your development board.  On my development board, the BTN is connected to PA2 and the LED is connected to PA6.

#define LED (1 << PA6)
#define BTN (1 << PA2)

8. Build the project:

$ make

9. Program the AVR using the writeflash target included in the makefile:

$ sudo make writeflash

Ensure that the program works as expected.  The LED should turn on when the button is pressed.  The LED should turn off when it is released.  Recall that this assumes your button is active low.  Congratulations, you have just created your first AVR project!

Continue reading »]]> This brief tutorial demonstrates how to read, write, and erase an AVR chip using AVR Dragon.  This tutorial assumes that you are using Ubuntu for your development environment.  This tutorial also assumes that you have an AVR development board running a demo program.  The JTAG port is used in this tutorial, but the ISP port can also be used.  Simply replace “dragon_jtag” with “dragon_isp”.

1. Install AVRDUDE:

$ sudo apt-get install avrdude

2. Read demo program from development board:

$ sudo avrdude -p m128 -c dragon_jtag -P usb -U flash:r:flash.hex:i

3. Erase development board:

$ sudo avrdude -p m128 -c dragon_jtag -P usb -e

4. Reprogram the development board:

$ sudo avrdude -p m128 -c dragon_jtag -P usb -U flash:w:flash.hex:i

Continue reading »]]>

Recently I was trying to count the number of n-bit numbers that have an equal number of 1′s and 0′s.  For example, there are 6 such numbers for 4-bit long numbers (0011, 0101, 0110, 1001, 1010, 1100).  I wrote a simple program to count such numbers for arbitrarily long numbers.  However, the program was computationally complex and it took a long time to compute the result for large values of n.  After spending some time trying to figure out the equation myself, I searched the internet and stumbled upon Catalan numbers.  I determined that the equation is related to Catalan numbers.  I included the equation below because I couldn’t find it anywhere else.  Also, I don’t have a formal proof, but it seems to work.  Enjoy!

Number of n-bit numbers that have an equal number of 1′s and 0′s = (m+1) * Cm, where m = n/2 and Cm = mth Catalan number

Continue reading »]]>

After many months of working on my Arduino based project, I decided to finalize my project by making my own custom PCB.  At first I wanted to design a PCB that connected to the Arduino through a series of cables.  After some thought however, I realized that a shield would be better because it would eliminate the need for cables.  This tutorial assumes an understanding of Cadsoft Eagle.  For more information about Eagle, see the Eagle Tutorials section below.  Here are the steps to make your own Arduino shield:

1. Part Selection- Carefully select your parts. Ensure that your parts meet your performance and power requirements.  It is better to carefully choose your parts now, than wish you chose something else later.
2. Prototype – Prototype your design on a breadboard.  Ensure that your functional, performance, and power requirements are being met.  Change your design as necessary.  Do not begin designing the PCB until you are completely satisfied with your prototype.
   Figure 1:
   Breadboard prototype
3. Schematic Capture
   1. Add Custom Parts to Eagle – Place all of your parts in the schematic before drawing any wires.  This allows you to identify which parts you will need to create yourself.  I had to create a custom part for the Arduino.  Drawing a symbol for the Arduino was easy.  Drawing the package was a little bit more difficult because I had to determine the spacing between the headers.  I easily obtained this information from the Arduino Eagle files which I downloaded from the Arduino website.  Download my Eagle Arduino library here.
      Figure 2:
      Header locations relative to one another.  I obtained this information from the Eagle file.

      
      Figure 3:
      Arduino symbol and package that I created in Eagle.

   2. Connect Parts - After placing all of your parts in the schematic, carefully connect your parts together using the wire tool.  If you make a mistake on your schematic, it will ultimately show up on your PCB.
4. PCB Layout - Place the parts on the board.  If your PCB is long enough, the PCB will rest on top of the USB connector on the Arduino.  Parts and traces should not be placed here because it could potentially short out your PCB.  I accidentally placed the DC power connector in this area. Fortunately,  I was able to insulate the USB connector with a piece of electrical tape.  Also, follow PCB layout guidelines.  I learned this the hard way when I discovered that the rapid switching of the transistors was inducing a voltage in one of the traces connected to the button.
   Figure 4:
   I made the mistake of placing a part above the USB connector.  I prevented the part from shorting out by placing some electrical tape on top of the USB connector.

   
   Figure 5:
   The shield also doesn’t sit properly because of my poor layout.

5. PCB Fabrication – Generate the CAM files.  You could fabricate the PCB yourself, but I highly recommend BatchPCB.  BatchPCB fabricates inexpensive, production quality PCBs.  The only drawback is that you have to wait three weeks to a month to receive your order.  BatchPCB has a tutorial on generating the files that they need to fabricate your PCB.
   Figure 6:
   Final product from BatchPCB.

Final Thoughts
Although I am not happy with the way my PCB turned out, I learned valuable information about PCB design.  I am sure that if I follow PCB layout guidelines, I can get this PCB to work properly.  I hope people can learn from my mistakes on this project and design a better Arduino shield of their own.

Eagle Tutorials
Schematic Capture
Creating Custom Parts
PCB Layout
Generating CAM Files

Continue reading »]]>

I made several improvements to my light bar controller.  I added a push button that pauses the controller on a desired color. I added a red LED to indicate if the controller is paused.  I also modified the light bar so that it easily plugs into the breadboard.  I did this by replacing the polarized right angle connectors with non polarized headers (one straight and one right angle).  The improved controller also uses the Bare Bones Board from the Modern Device Company instead of the Diecimila.  Below is an updated schematic of the controller. Get the code here.