Nick Weil's Blog

DIY: Custom Graduation Photo Cards

2012-05-07T22:58:00.000-07:00

The final result of my DIY photo card adventure

Since I'm graduating this May, I decided to send out a special graduation thank you note to my friends and family. I started using the photo card creator on the Walgreens website but quickly got frustrated with the lack of customization tools. Specifically, I wanted custom fonts and also to change font colors within a text box. Being an incurable DIYer, I thought to myself: "I can make this myself in GIMP and customize it all I want!"

What size card? I started with the assumption that the card would be 5x7 inches, but I changed my mind when I realized I only had letter envelopes (4 1/8 x 9 1/2) which wouldn't fit a 5x7 card. So, I switched to a 4x8 inch card which would fit in a letter envelope. Ultimately, the website where I ordered my prints supplied me with envelopes for free so this was all for naught, but I'm still glad I went with the 4x8 format.

What resolution? For photo prints, you need a pretty high resolution for the photo to look good. For my 4x8 card, the GIMP "canvas" was 2880x1440 pixels.

What design? I came up with a template for my card:

General template for graduation photo card (2880x1440 px)

In general, pictures on the right and text on the left. I thought that four pictures of myself looked a bit vain, so I made the smallest frame an "object" picture. For my object, I used a cool picture of the golden gate bridge. The outside black border is 20 pixels and the inside "framing" is 10 pixels.

You might notice a blank black area on the far left side which seems unused. This is a actually a buffer area to make sure the text won't get cut off during printing. The size of buffer you need depends on who you're ordering prints from. With pictures, having the edges cut off is not not the worst thing in the world, but text becomes unreadable with missing letters. I would say a good rule of thumb is to reserve 6% of the total width and height for a buffer. That is, 3% of the total width reserved on both the left and right and 3% of the total height reserved on both the top and bottom. Trust me, it's better to be safe than sorry (see below):

Edge text cut off on prints=FAIL!

How to put it together? I'm no GIMP expert, so perhaps someone can offer a better way to do it. But I simply created a black "frame" layer with transparent squares at the photo locations. This part took a bit of planning and some back-of-a-napkin calculations, but it wasn't too hard. As a sidenote, I found "Guides" to be especially helpful to line things up appropriately. Try selecting one of the transparent squares and going to Image>Guides>New Guides From Selection. This will create four Guides; one for each side of the square.

GIMP-tastic photo editing fun

Once you have the frame completed and the pictures you want picked out, open the pictures as new layers. Then you need to adjust the pictures to the right size and frame them in the square the way you want.

The main paragraph of text is simple - just use the text tool. One tip: make the fancy text stuff on a separate GIMP canvas and import the final product into your card canvas. I did that for the "Thank You" header and the major and school overlay at the bottom.

Where to print it? It was surprisingly hard to find a site that will make 4x8 custom prints. I finally stumbled upon artscow.com and ordered from them. They have an elaborate client card designer, but all I did was upload my image, place it on a card and select "Apply to All." I ended up ordering 30 cards and it cost about $15 including shipping.

I received my package in the mail about 2 weeks later, sent from an address in Hong Kong. The package included all of my cards, nicely wrapped and 30 envelopes to send my cards in. I was very satisfied with the whole process.

Did it save money? No.

Did it save time? No.

Was it worth it? Yes.

Another view of the final product

Interesting Infrastructure: Caltrans and Music Notes

2012-05-02T08:39:00.000-07:00

These photos are from Cotati, CA in the northern bay area. As you can see, Caltrans incorporated a music note motif into their new overpass project. Since Cotati is sort of a hippie town, and also home of an annual Accordian Festival, it fits the local vibe. The motif has a treble clef sequence and a bass clef sequence, and they appear on the sound walls, the retaining walls and on the actual overpass. I alternate between thinking this is really cool and thinking it is a huge waste of money, but here are the pics anyway:

Sound wall in final stages of project

Overpass with alternating design

Retaining wall with treble clef design

Retaining wall with bass clef design

Sound wall with temporary frames to hold design in place

The local Press Democrat's Road Warrior blog investigated this and reported:
"...Leah Haygood of the landscape design firm for the 101 project, Haygood & Associates in Albany, composed the song melody. Caltrans spokesman Bob Haus said the song is called 'Reaching For Center … Reaching For You.' Haygood couldn’t be reached for comment. But once on paper, not all of the notes worked visually, so some were moved up or down until they did, he said."

Note that neither "melody" has a time or key signature, so it is impossible to accurately "play" the notes. But we can make some assumptions and try to reconstruct what it is supposed to sound like. If we assume it is has a 4/4 time signature, C key signature and overlay the treble clef and bass clef, it would look something like this:

And at 90 BPM, it would sound like:
Which does not sound quite right. Clearly there is still more work to do reconstructing this melody.

LINKS:
Article with more info about the project:
http://roadwarrior.blogs.pressdemocrat.com/13483/cotatis-musical-sound-walls-overpass/

GIMP: Adding New .gpl Palette

2012-03-30T23:19:00.001-07:00

Palettes are very useful if you want to have a consistent color scheme. I find that having good colors readily available helps in the creative process as well. You can find great user-created palettes for free at kuler.com (link) and colourlovers.com (link); using these palettes can give your project a very professional look.

Palette dialog

The easiest way to import a palette is to simply drop the file in the the file system GIMP created when it was installed. On Windows XP, the file would be: C:\Documents and Settings\<fill in user name>\.gimp-2.6\palettes. On Mac OS X, it would be: Users/homefolder/library/applicationsupport/ GIMP/palettes. I am not familiar with the location on other operating systems but if you look around a bit it should be obvious. Note that the file must have the file the extension .gpl to work. Also, you must restart GIMP for the palette to show up.

An alternate way to add palettes is to use the user interface. Since this does not depend on the file structure, it should be valid for all operating systems. From the image window, go to Windows>Dockable Dialogs>Palettes and click to open the Palettes dialog. On the Palettes dialog, click on the little arrow on the top right. This brings up a menu where you go Palettes Menu>Import Palette. From here, you simply select "palette file" as the source and browse to the desired .gpl file.

FYI, I used GIMP 2.6.11 for this tutorial.

Import New Palette dialog

Arduino: Sending Hex Bytes to Serial Devices

2012-03-21T15:01:00.000-07:00

I have been working on a project which involves an Arduino communicating serially with an LCD display device. Through a lot of trial and error, I finally figured out that when you want to send a HEX-encoded byte from the Arduino, you need to use the Serial.write() command rather than the Serial.print() command. The Serial.print() command works find when you are sending an ASCII byte but it will not work when you try to send a HEX byte. The right and wrong ways are below:

//Serial.print('U');  <----right (ASCII)
//Serial.write('U');  <----also fine (ASCII)
//Serial.print(0x55); <----WRONG! (HEX)
//Serial.write(0x55); <----right (HEX)

LINKS:
Similar problem and solution: http://www.arduino.cc/playground/Learning/SparkFunSerLCD

STK 200: First Program (LED Blink)

2012-03-01T14:25:00.001-08:00

For this program, you should already have AVR Studio 5 and AVRISP-U installed on your computer. If you don't, visit my previous post Getting Started Programming Guide (link). This is a simple program which simply makes the built-in LEDs to blink. I'm going to use C for this program because the code looks really simple. The assembly version is not really difficult either but we'll keep it simple for now. Note that AVR Studio 5 has a built-in C compiler. You might remember for AVR Studio 4, you had to download AVR GCC and integrate it. If you downloaded AVR Studio 5, you already have the C compiler.

What will the program do? If you look at the STK 200, there is a row of 10 LEDs numbered from 0 to 7 then "ISP" and "ON." These are the built-in LEDs. Our program will make the LEDs numbered from 0 to 7 blink on and off at a rate perceptible to the human eye. In microcontroller terms, this means physically connecting the LEDs to PORTB and sending alternating HIGH/LOW signals to PORTB. Note that is all output - no input. If you don't know what PORTB is, check my Basic Layout Guide (link).

Step 1 - Create a new project: Go ahead and open AVR Studio 5. From the startup screen, go to File>New>Project... and you should see a New Project dialog box. At the top left of the dialog box, select the C templates and then choose "C Executable Project" in the middle of the screen. At the bottom, fill in "blink" as the name and this should automatically fill the solution name field with the same text. Also, make sure that the "Create directory for solution" box is checked. This checkbox will not affect your code at all, but it will keep your AVRStudio folder better organized. Look at the picture below and make sure your screen looks the same:

STK 200: New Project Dialog Box

Click OK and you should see a Device Selection dialog box. Here, you select the name of your microcontroller. If you don't know what microcontroller you have, I'd recommend looking at my post Switching Microcontrollers (link). I'm using an ATmega32, so I selected that. Hit OK and you should reach the actual C file that you are going to edit. The screen should look something like what is below:

STK 200: Blank C Template

Step 2 - Writing the code: As you can see, the program automatically generates some code to make you life easier. Since our program is so simple, we only need to add a couple lines and we are done. Basically, the code section (not including the top comments section) needs to read:

#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
    DDRB=0xFF;          //PORT B (LEDs) output
    while(1)
    {
        PORTB=0x00;     //LEDs ON
        _delay_ms(1000); //delay
        PORTB=0xFF;     //LEDs OFF
        _delay_ms(1000); //delay
    }
}

Once this code is entered, you need to build it. Hitting F7 is the easiest way to do that. Otherwise, go to Build>Build Solution. At the bottom of the screen you should end up with a message saying "Build succeeded."

Step 3 - Make the connections: First, make sure that PORTB is connected to the LED header using the ribbon cable supplied with the kit. Then, connect the board to the computer using the ISP also supplied with the kit. If this doesn't make sense, look at the picture below and make it look the same:

STK 200: Make the Connections

Step 4 - Transfer program to board: Now, we need to transfer the built program from step 2 to the microcontroller. Back in AVR Studio, go to Tools>AVRISP-U and you should see the AVRISP-U software pop up. Check the bottom left corner for a green light and text describing the correct device (in my case ATmega32). If you get a red light, check the hardware connections and try again. Now, we need to load the hex file to flash, so hit Ctrl+O or go to File>Load>Flash... and browse to the hex file of the program you just wrote. On my machine (windows xp), the projects are stored in separate files in My Documents\AVRStudio. I named my project "blink" and used the default file location, so the hex file had the following path:
C:\Documents and Settings\Nick\My Documents\AVRStudio\blink\blink\Debug\blink.hex

STK 200: Loading Program with AVRISP-U

Hitting open will load the hex file into the AVRISP-U software. Before you load the program onto the board, you should probably erase what is currently in the microcontroller's Flash, so go to Device>Erase. After that, hit Ctrl+Alt+F6 or go to Device>Program>Flash and the hex file you loaded previously will be transferred to the board.

At that point, the LEDs should start blinking. The program will continue forever (or until you erase it or turn it off).

STK 200: Getting Started Programming Guide

2012-02-17T11:00:00.000-08:00

To start programming the STK 200, you need to download some software. Namely, you need AVR Studio and AVRISP-U. I talked about the basic layout of the board in a previous post (link), so check that out if some of the terms I am using are unfamiliar. I broke the process into three steps below.

Step 1 - Download AVR Studio 5: I started programming with AVR Studio 4, but if you are starting today, you might as well start with the new AVR Studio 5 release. The program is built using the Microsoft Visual Studio Shell (VSS) so the user interface is very similar to Visual Studio. I suppose this can be a good thing for those who like Visual Studio and a bad thing for those who don't. Overall, it seems to have a lot of convenient features such as IntelliSense and debugging interface.

So to get the software, go to the AVR Studio 5 page (link) from Atmel and download the software package you need. I recommend downloading the package that includes VSS and .NET 4.0. The software is completely free but you do have to fill out a registration form. The installer is pretty big (the one including VSS and .NET is over 600 MB).

STK 200: AVR Studio 5

Step 2 - Download and initialize AVRISP-U: The other piece of software you will need is "AVRISP-U" from Kanda. This will take the hex file you created using AVR Studio and send it through the ISP connecting your USB port to the board and program the chip. This package is not nearly as big as AVR Studio (~5 MB). Go ahead and extract the .exe file and install the software. After that is complete, plug in your STK 200, turn it on, and connect the ISP from the board to your USB port. If that is confusing, look at the image below:

After it is all connected, you might get a notice that the ISP's driver was installed. Now launch AVRISP-U. It should automatically detect the microcontroller in the STK 200. You should get a screen similar to the image below, with a green dot on the bottom left and a message saying that the ISP is initialized:

STK 200: AVRISP-U

Step 3 - Integrate AVRISP-U with AVR Studio 5: Open AVR Studio 5 and go to Tools Menu > External Tools. You will see the External Tools dialog box. If this is the first time you have ever accessed this dialog, there should be a placeholder tool named "[New Tool 1]." You can overwrite this tool. Or if you have previously entered tools, simply click the Add button near the top right. Now, you will fill out some information about the new programmer you are adding. You can see the proper entries in the screenshot, or I listed them as text below:

Title: AVRISP-U
Command: C:\Program Files\embres\AVRISP-U\AVRISP-U.exe
Arguments: $(ProjectDir)$(ProjectFileName)
Initial Directory: $(ProjectDir)

What does all this mean? The "Title" is simply the name given to the new programmer in AVR Studio. "Command" is the path to the .exe file which corresponds to the programmer; in our case: AVRISP-U.exe. The location of this file all depends on where you chose to install the AVRISP-U software during setup. If you are following step 2 of my guide and downloaded the software from Kanda's website and you kept the default path during the installation process, the path I have given should be correct. If you installed the software from the CD that was shipped with the kit, the path is likely different. Browse around in the Program Files folder to find it for sure. It should resemble something like: C:\Program Files\Kanda AVR\avrisp-u\AVRISP-U.exe. The next two lines ("Arguments" and "Initial Directory") correspond to where the programmer can find the files it needs to program the microcontroller.

STK 200: Adding AVRISP-U to AVR Studio 5

Hit OK and it should be installed! To check that it worked, go to the Tools Menu in AVR Studio 5 and look to see if there is a menu item for AVRISP-U.

LINKS:
AVR Studio 5: http://www.atmel.com/dyn/products/tools_card.asp?tool_id=17212&source=avr_5_studio_overview
AVR Studio 4: http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725
Kanda Software Download Page (AVRISP-U is near the top): http://www.kanda.com/downloads2.php

Interesting Infrastructure: Mouse shaped wetland

2012-02-07T15:46:00.000-08:00

Check out this satellite imagery from Petaluma, California, a city of about 60,000 people in the northern bay area. The city completed construction of a new wastewater treatment plant, the Ellis Creek Water Recycling Facility, in 2009 and they included some polishing ponds which had a very interesting shape. Environmental artist Patricia Johnson worked with the city and their consultants to make this wetland park a unique piece of artwork. The shape is a reference to the harvest field mouse, an indigenous species in the area near the Petaluma River. You can see the actual treatment facility towards the top right of the image.

Mouse shaped wetland: Raw image

Mouse shaped wetland: Mouse outlined

If you would like to check this out in your own browser, type “shollenberger park petaluma ca” into google maps and you will see the mouse shape just a bit to the east.

LINKS:
Article detailing the Patricia Johnson’s work: http://www.petaluma360.com/article/20100520/COMMUNITY/100529959?p=1&tc=pg
Article about the new wastewater plant: http://www.petaluma360.com/article/20090731/COMMUNITY/907319990
More about Patricia Johnson: http://patriciajohanson.com/archive/metroactive-01-2006.html

STK 200: Basic Layout Guide

2012-02-01T13:13:00.000-08:00

The Kanda STK 200 has a lot of really cool features. But when I first got the board, I didn't even know where to begin. This post goes over the board's basic layout and the main features that it includes.

I/O: Really, the core function of a microcontroller is Input/Output. In fact, out of the ATmega32's 40 pins, 32 pins are set aside for I/O. They are organized into four 8-pin ports named PORTA, PORTB, PORTC, and PORTD. The STK 200 makes it really easy to access these ports by giving them each headers. The board even labels the headers using the standard naming convention established by the AVR family (PORTA, etc.). Each header includes it's own VCC and GND, which devices almost always require. LEDs and switches are probably the most common form of I/O; conveniently, the STK 200 has 8 LEDs and 8 switches built into the board. You can dedicate ports to the LEDs, the switches or both using a 10-pin ribbon cable provided with the board and pictured below. PORTB is lined up with the LED input header and PORTD is lined up with the switches output header for an easy connection.

STK 200: I/O

Programming: The STK 200 is shipped with a USB programming device, called an ISP (In-System Programmer). It attaches to the board via a 10-pin header outlined in the picture below.

STK 200: Programming

LCD/USART: The board makes it really easy to set up serial communication with a computer and also to display output on an LCD screen. In general, I call serial communication USART which stands for Universal Synchronous-Asynchronous Receiver/Transmitter. This is a fancy acronym which refers to a standard way that devices communicate. The board has a RS-232 port which facilitates USART communication. RS-232 used to be a standard port on computers but they are not so common today. I bought an RS-232 to USB cable which basically turns one of the USB ports on my laptop into a simulated RS-232 port. For LCD screens, the STK 200 has 11 I/O pins plus a VCC and GND dedicated to driving a display. The LCD screen I bought was shaped in a way that it would not sit flat on the board's pins. To counteract that, I bought headers to "raise" the pins over the rest of the board. You can find similar headers from most electronic parts websites such as Jameco, Digi-Key or SparkFun. There is one thing you should be careful of, however. There is an LCD Disable jumper which I outlined below (middle red box). If this jumper is shorted, the LCD pins simply do not work. I spent quite few hours pulling my hair out before I discovered that. The LCD screen shown in the picture is a 16 character by 2 line display which I used with the board.

STK 200: LCD/USART

Power: I had to purchase a 9V power supply for my STK 200. It uses the standard 2.2 mm DC input jack. There is also an ON/OFF switch so you don't have to pull out the power supply to turn the board off. When the board is turned on, a power indicator LED, outlined in red below, lights up.

STK 200: Power

Microcontroller Sockets: I went over these in detail in a previous post (link). I typically use the 40-pin ATmega32, which you can see in the picture.

STK 200: Microcontroller Sockets

Note that this is not a comprehensive guide. But this includes the main features you will encounter in an introductory lab or class.

STK 200: Switching Microcontrollers

2012-01-20T12:38:00.000-08:00

When I bought my Kanda STK 200, it was shipped with an ATmega8515 microcontroller. While the 8515 is a fine microcontroller, I wanted to replace it with an ATmega32 due to the latter's more robust features. Namely, the ATmega32 has 32KB of flash memory compared to the 8515's 8KB. Also, the 8515 has no built-in analog to digital or digital to analog conversion while the 32 does. If you are also interested in switching the microcontroller on the STK 200, here is a quick guide:

Sockets on the development board: When you look at the board, you can see various sockets. Check out the following image to see the available sockets and what their name is:

STK 200: Sockets on the Development Board

Socket support: It took me a long time to find this extremely helpful documentation. I finally found it in the datasheet on the Kanda website. As you can see, it lists all the supported microcontrollers and which socket they should be placed in. Obviously, all of these are AVR microcontrollers from Atmel. For my microcontrollers, you can see that the ATmega8515 should be placed in socket "40D" while the ATmega32 should be placed in "40A."

STK 200: Socket Support

Label on microcontroller: What if you have a microcontroller and you are not sure what it is? Just look on the top of the chip and you should see a name:

Label on MCU

When I first got my ATmega32, I mistakenly put it in the 40D socket because I assumed it would go in the same socket as the ATmega8515. As you can tell from the socket support sheet, I was wrong. I was actually able to program the chip fine, but I kept getting very strange results from my programs. I finally tracked it down and realized it was an analog to digital conversion issue. That's when I realized the chip was in the incorrect socket. That was very frustrating but at least it did not damage the chip!

LINKS:
ATmega32: http://atmel.com/dyn/products/product_parameters.asp?category_id=163&family_id=607&subfamily_id=760&part_id=2014&ListAllAttributes=1
ATmega8515: http://www.atmel.com/dyn/products/product_card.asp?part_id=2006
Kanda: http://www.kanda.com/

Fundamentals of Engineering/EIT Exam Strategy

2012-01-18T21:01:00.000-08:00

I wrote some general tips for the Fundamentals of Engineering Exam in a previous post (link). Here are test taking strategies to go along with those.

FE Exam: Multiple Choice

Overall strategy: Become an expert in the subject areas that you are most familiar with and know the basics of all other subjects. There is a reason the engineering profession is split into specialties (civil, mechanical, etc); there is so much to know that it is almost impossible to be an expert in everything. Furthermore, we all have our own ways to solve problems. Those thought processes might work especially well on certain subjects and not so well on other subjects. I found that it is much more productive to focus on the subjects that I have a background in rather than try to learn an unfamiliar subject from scratch.

Guessing: The entire test is multiple choice with four possible answers. This means that if you completely guess, theoretically you have a 25% chance to get the correct answer. Further, if you are able to eliminate one of the possible answers, you now have a 33.3% chance to pick the right answer. Eliminating two possible answers leaves you with a 50% chance and, according to my study manual, a passing score on the FE Exam is a bit less than 50%. So, theoretically, if you were able to eliminate two possible answers for every question on the test, you should pass. Of course, this is not practical. In reality, there are some questions where you absolutely know the answer and some questions where you have no idea, but this does highlight the effectiveness of strategic guessing.

Subject areas: In the front of the NCEES handbook, there is a breakdown showing what percentage of the test is related to each subject area for the morning and afternoon session. I reproduced the breakdown for the morning session below:

Mathematics: 15% (equivalent of 18 questions)
Engineering Probability and Statistics: 7% (equivalent of 8.4 questions)
Chemistry: 9% (equivalent of 10.8 questions)
Computers: 7% (equivalent of 8.4 questions)
Ethics and Business Practice: 7% (equivalent of 8.4 questions)
Engineering Economics: 8% (equivalent of 9.6 questions)
Engineering Mechanics (Statics and Dynamics): 10% (equivalent of 12 questions)

Strength of Materials: 7% (equivalent of 8.4 questions)
Material Properties: 7% (equivalent of 8.4 questions)
Fluid Mechanics: 7% (equivalent of 8.4 questions)
Electricity and Magnetism: 9% (equivalent of 10.8 questions)
Thermodynamics: 7% (equivalent of 8.4 questions)

I suggest you approach this is to separate the subjects into two categories: subjects that you are comfortable with ("good subjects") and the subjects you are not comfortable with ("bad subjects"). Personally, I felt comfortable with Math, Computers, Ethics, Economics, and Electricity. Now, set a goal that you will get a score of 75% on the "good subjects" and 33% on the "bad subjects." Note that 75% is pretty high goal - this means that you get three out of every four questions correct. I chose 33% for the "bad subjects" because it corresponds to the probability of guessing when you have eliminated one possible answer. This come from the idea that you should be familiar enough with your "bad subjects" to have a general idea if one answer is out of whack. If you want to get really nerdy, you can create a table to see what you would score if you followed achieved this goal. The one I made is below:

Subject	Percentage of Test Content	My Score (Out of 100)	My Weighted Score
Mathematics	0.15	75	11.25
Probability & Stats	0.07	33	2.31
Chemistry	0.09	33	2.97
Computers	0.07	75	5.25
Ethics	0.07	75	5.25
Economics	0.08	75	6
Statics & Dynamics	0.10	33	3.3
Strength of Materials	0.07	33	2.31
Material Properties	0.07	33	2.31
Fluid Mechanics	0.07	33	2.31
Electricity & Magnetism	0.09	75	6.75
Thermodynamics	0.07	33	2.31
		TOTAL SCORE (%)	52.32

If I exactly followed my projections on the test, I would score over 50% for the morning section. In reality, I am slightly more confident in certain “bad subjects” and slightly less confident in some “good subjects” but this at least gives me a baseline goal to achieve for a passing score.

Time per question: For the morning session, you have 4 hours to complete 120 questions. This works out to 2 minutes per question. For the afternoon session, you have 4 hours to complete 60 questions. This works out to 4 minutes per question. In general, I would say that time is not an issue on the afternoon portion. Many people finish early and leave. The morning session, on the other hand, is a race against the clock. I believe my overall strategy can be applied here. As I said, it is pretty much impossible to be an expert in every single subject on the test. Thus, there will be questions where you completely guess. Taking into account the time to read the question and fill in the answer sheet, a guess should take about 20 seconds. Suppose you guess on 20 questions throughout the morning portion; this frees up 33 minutes and 20 seconds to be distributed among other questions. If that is distributed evenly, it results in an extra 20 seconds per non-guessing question. That extra time can be applied to questions where you know you are on the right track but need more time to make sure you have the right answer.

Morning/Afternoon session weight: Both the morning and afternoon portions are weighted equally, so 1 correct afternoon question is "worth" 2 correct morning questions. Basically this means you should not neglect studying for the afternoon session because it is your major/specialty and you feel confident in that material. The afternoon questions are difficult so you need to study for those too. Since there are fewer questions, the stakes are higher to solve each one.

Good luck on the exam!

TI-36X PRO: Programming Bug Info (VIDEO)

2012-01-17T15:30:00.000-08:00

In a previous post (link), I explained why the TI-36X PRO is a great calculator is you are taking the Fundamentals of Engineering or PE Exam. But it has one problem: a programming bug. Essentially, the bug is a display problem which only occurs when you try to display a mixed fraction involving pi, but still, any time your calculator is giving you wrong answers it is a serious problem.

I made a video to illustrate the bug, embedded below:

To check if your TI-36X PRO has the bug, first make sure you are in MathPrint mode. You can check this by pressing $mode$ and scrolling down to the bottom of the list of options. Now, you need to tell the calculator to display answers in mixed fraction form. To do this, type $1.75$ into he command line, then press $math$ then $1$ then enter. You should see the result $1\frac{3}{4}$. Then type $\pi12.5^2$ into the command line. When you hit $enter$, you should receive the answer $490.8738521$. Now press the answer toggle button (it is directly above $enter$) and your calculator will display $154\frac{\pi}{4}$ if your calculator has the bug. The mathematically correct answer would either be $\pi154\frac{1}{4}$ or $\frac{\pi654}{4}$. Remember to clear the memory (hit $on$ and $clear$ at the same time) after you try this!

Overall, I’m still a fan of the calculator. To avoid the bug, I never try to convert anything to a mixed fraction. There are very few times where I ever need a mixed fraction anyway. You can get all the information you need in either decimal or improper fraction form. I actually used this calculator on the Fundamentals of Engineering Exam and I was very happy with it.

LINKS:
TI-36 Wikipedia Page: http://en.wikipedia.org/wiki/TI-36#Programming_Errors
The Consumerist Article: http://consumerist.com/2011/09/this-texas-instruments-calculator-cant-calculate-correctly.html
Product Guidebook from TI: http://education.ti.com/downloads/guidebooks/scientific/36xPro/TI36PRO_Guidebook_EN.pdf
Here is a video from MrTechLabs describing the same problem:

Fundamentals of Engineering/EIT Exam General Tips

2012-01-13T08:18:00.000-08:00

I took the Fundamentals of Engineering Exam in October 2011. Two months later I received the results, stating that I passed (YAY!). Hopefully I can pass on a couple tips from my experience with the test!

Pass the FE Exam

Waiting time to get results: Like I said before, it took me two months to get my results. I took my exam on October 29, 2011 and on December 20, 2011 I got an email saying “Your results from your recent NCEES exam have been released. To access your results, log into your NCEES exam registration account.” When I logged into my NCEES account I was able to see a message stating that I passed. I got an actual letter in my mailbox about a week after that.

Calculator: The most important tip I can give is to get a good calculator and learn how to use it to the fullest extent. I’m partial to Texas Instruments (TI) calculators, so I looked up what was allowed for the exam. I found that, for TI branded calculators, “TI-36” must be part of the name. The most powerful calculator fitting that description was the “TI-36X PRO,” so I ordered it. I did a review of the calculator in a previous post (link). Bottom line is that it is a great calculator for this test. I know that some people take pride in doing calculations in their head, but during the morning portion, you will have so many questions to answer that you will likely be crunched for time. Some of the math questions on the morning portion will simply take a couple keystrokes on the right calculator. This time savings will help you when you reach the subjects you struggle with.

Handbook: The second most important tip I can give is to print out the NCEES handbook (the PDF they give you with all the formulas), get it bound and use it to solve a bunch of practice problems. I know that we are in the digital age where we mostly look at documents on a computer screen, but this is one document where you need to actually have a hard copy. Note that the handbook is over 200 pages, which makes it very unwieldy if it is not bound. Again, like the calculator, some of the questions on the morning exam will be answered implicitly by the handbook. On exam day, when you are struggling with a problem, you will have two resources to help you out: your handbook and your calculator. If you are not familiar with either resource, they won’t be very much help.

Review Manual: My school did not offer a review course, so I bought Michael R. Lindeburg’s FE Review Manual. This book only prepares you for the morning portion but it does a great job. It has practice questions at the end of each chapter and a full 4 hour practice test in the back. In general, I felt like the questions on the actual FE Exam were easier than Lindeburg’s practice questions. Perhaps this was on purpose, but it made me feel confident on exam day. Also, the pages before the first chapter contain very good general information about the exam, such as what to bring and what to expect on exam day. I would recommend getting this book.

Also check out my post on FE Exam Strategy (link)

LINKS:
Lindeburg's Review Manual: http://ppi2pass.com/shop/fe-eit-exam/fe-eit-exam-review-materials
NCEES: http://www.ncees.org/
Great resource site: http://www.feexamreview.com/

Product Review: Texas Instruments TI-36X PRO Calculator

2012-01-12T08:46:00.000-08:00

Summary: The only reason you need this product is if you are taking a test which has a strict calculator policy, such as the Fundamentals of Engineering or PE Exam. It has high level math capabilities without the graphing and programming of TI-89, TI-92 etc. But if you are taking one of those tests, this calculator is a fantastic.

Price: Under $30 (I bought mine from Amazon) And here is a link from officemax for $22.99:
TI-36X Pro Scientific Calculator 36PRO/1L1/A (Google Affiliate Ad)

Review: The TI-36X PRO is a calculator which seems to be designed specifically for standardized testing. Basically, it takes most of the features of an advanced graphing calculator, such as a TI-89, and puts them in a package that is allowed on your standardized test. I bought this calculator for the FE Exam and I as amazed at how much it could do.

Solver: One of the most powerful features is the numerical solver. You can enter any single variable equation and solve for the variable (a numerical result). This comes is so handy on a test where you are provided a formula and the variable you need to solve for is not isolated. You have to be a little careful, though. The numerical solver only returns one solution, even though if the equation you entered has multiple solutions, and there is no warning. The polynomial solver, on the other hand, does return all possible solutions. Obviously, the equation must be in the form of a polynomial to use this feature but usually that is not a problem. As if that wasn’t enough, there is also a system solver. This can be used when you have a 2x2 or 3x3 linear system of equations. This feature is somewhat duplicative since you can also just transform a representative matrix into reduced row echelon form (rref) on the matrix menu, but oh well.

Calculus: The TI-36X PRO does calculate definite integrals (no indefinite). And the calculator will take the first order derivative of any single variable function, evaluated at a given value. The common theme here is that you will get a numerical result. One thing the calculator does not do is symbolic manipulation, where you will get an answer with variables in it. But still, being able to do integrals and derivatives is very useful. In fact, on the FE Exam I had physics questions which boiled down to simple derivatives (position/velocity/acceleration) and the calculator helped me out tremendously.

Matrices/Vectors: You can create matrices (up to 3x3) and manipulate them using the following functions: Transpose, Inverse, ref, and rref. You can create vectors (up to a dimension of 3) and use the dot product, cross product and magnitude functions.

Electrical: As an electrical engineering student, I was very happy that the calculator made it easy to switch complex numbers from polar to rectangular format. I was also happy with digital/logic type features. You can convert numbers to hexadecimal, binary or octal base and even create logic equations using and, or, xor, not, nand and 2’s complement.

Statistics: I am not a statistics expert, but the calculator give me everything I needed on the FE exam. It has built-in functions which take lists of data points (max 5 per list), and calculates all of the statistics you would ever want (at least on the FE Exam). There is also a linear regression function which I found useful.

Conversion/Constants: The built-in conversion function is very useful. It includes English-Metric, temperature, speed/length, pressure and power/energy conversions. Granted, this feature is somewhat limited to common, basic conversions but often that is exactly what you need. The calculator also contains 20 scientific constants, from the acceleration due to gravity to the charge of an electron. Again, not a comprehensive list but useful nonetheless.

Programming Bugs: I wrote a post (link) all about the programming bug. There is more info on the Wikipedia page for the TI-36 and also here (link). The bug only affects mixed fractions that include $\pi$, but make sure you try my example to check if your calculator has the bug.

Of course, there are other features of this calculator but I have went over the features I found most interesting and useful. If you are an engineering student or someone else who needs to calculate integrals or derivatives, get a TI-89 or TI-92 and make life easier for yourself. On the other hand, if you are someone who does not do any high level math, get the simplified TI-30X and ditch all the bells and whistles that you don’t need. The TI-36X PRO is in a niche between those extremes. If that is what you need, the TI-36X PRO is for you

Q&A: What is a development board?

2012-01-09T21:43:00.001-08:00

A development board is a printed circuit board with circuitry and hardware designed to facilitate experimentation with a certain microcontroller.

Imagine if you had a microcontroller which could do all kinds of cool things but to be able to use it, you had to set up a bunch of circuitry and hardware on your breadboard each time. Obviously, this would get sort of frustrating, especially when there are circuits which are going to be the same every time, such as the power circuit. Also there are certain hardware circuits which greatly aid testing and debugging such as pushbuttons and LEDs. Having all of the hardware and circuitry already constructed makes life much easier and is much more conducive to experimentation and general prototyping.

Typical components of a development board include:
-power circuit; typically set up to run off of a 9V power supply
-programming interface; an easy way program the microcontroller from a computer
-basic input; usually buttons
-basic output; usually LEDs
-I/O pins; to be used for everything else, motors, temperature sensors, LCD screens, etc.

Probably the most popular and recognizable development board is the Arduino, and for good reason. The Arduino is exceedingly simple to use and even open source. But there are many, many other great development boards such as the BeagleBoard, the Chumby board and the TI Launchpad. Again, these are only boards that I have had contact with but there are many others.

Working with development boards can be educational, fulfilling and fun. Go ahead and try working with one and I bet you will learn something new.

LINKS:
This is an incredible resource from Hack A Day: http://hackaday.com/2011/02/01/what-development-board-to-use/
Wikipedia on development boards: http://en.wikipedia.org/wiki/Microprocessor_development_board

blinky lights with interrupts

2011-06-07T20:53:00.000-07:00

In the previous post, I kind of glossed over the problem with using the built in delay function. I said that it would be better to use interrupts so I'll go more in depth about that.

The problem with using the built in delay is that CPU clock cycles are essentially wasted. In such a simple program like we had in the previous post, we are not worried about conserving clock cycles but you can imagine that in a very complex program you would want every clock cycle to do something. Once interrupts are set up and enabled, they will "interrupt" the program when a certain condition is met. In the case of delay, a timer counts clock cycles and once a certain number is reached, the program is interrupted and carries out a "service routine" specified by the programmer. Once the service routine is finished, the program returns to the line of code it was executing when the interrupt occurred.

To illustrate the difference between the two types of delays, I wrote a program that does the exact same thing as the program in the previous post but it uses interrupts rather than the built in delay. This program simply makes the built in LEDs turn on and off at a rate that is perceptible to the human eye:

#include <avr/io.h>
#include <avr/interrupt.h>

int main(void)
{
    DDRB = 0xFF;        //PORT B (LEDs) output
    TCNT0 = 0;          //timer starts at zero
    OCR0 = 200;         //and counts up to 200
    TCCR0 = 0b00001101; //CTC mode, internal clk, 1024 prescaler

    sei();              //global interrupt enable
    TIMSK = (1<<OCIE0); //timer0 overflow interrupt enable
 
    while(1)
        asm("nop");     //stay here....
}

ISR (TIMER0_COMP_vect)
{
    PORTB ^= 0xFF;      //toggle PORTB (LEDs)
}

So you can load this program using the same method as I showed before and see that the LEDs simply turn on and off. All the connections should be exactly the same.

Some notes on the program: we first set up timer0 by setting TCCR0 to the binary 0001101. Of course we could express this in hex or even decimal but for me, the binary makes it easier to understand whats going on. Using the 8 bits of the TCCR0 register, you can specify whether you want "normal mode" (based on overflow) or "CTC mode" (based on compare match). You can also specify a prescaler value which is multiplies the number of clock cycles needed for a count. In other words, a large prescalar makes a delay longer. For our purposes, we'll set TCCR0 for CTC mode and have a prescaler of 1024. TCNT0 is the register which counts upwards with the clock cycles so we want this to start at zero. OCR0 is the value that TCNT0 will count up to before the interrupt occurs, so we will set this to 200. Note that since this is an 8 bit register, the largest value possible is 255. The sei() command sets the global interrupt bit and TIMSK enables the various different conditions that can cause an interrupt. The one we want is OCIE0 (timer0 overflow) which is actually bit _. Finally, the asm("nop") is not necessary for the program to work but it makes it easier to simulate the program in the AVR Simulator.

Speaking of the AVR Simulator or debugger in AVR Studio, lets take a look at how to make sure the program works without even loading it on the AVR. After you have entered all the code and hit F7 for build, go to Debug on the top menu and select Start Debugging.

First notice that a yellow arrow is pointing to the first executable line of your code. If you hit F11, you will see that the arrow moves to the next line. This is called stepping through the code. One subtle thing to notice is that F10 steps OVER lines of code while F11 steps INTO lines of code. This comes into play when you have subfunctions within your main() function. You can step INTO the subfunctions or step OVER them. Anyway, lets look at the I/O view on the right side of the screen.

The I/O view should pop up automatically but if not you can hit Alt+5 to bring it up. From this view you can see that status of all the registers in the AVR which can be extremely useful. For our program, click on the TIMER_COUNTER_0 and check out the registers we were talking about before (OCR0, TCCR0, TCNT0 and TIMSK). Now step through the program and once you get to the asm("nop"), notice how the arrow just stays here every time you hit F11. This is because you are in a while(1) loop, so this would normally just go on forever but we have interrupts now so once the compare match happens we will escape the loop and perform the service routine. If you hit F11 a bunch of times you will see that TCNT0 is increasing slowly. This is because of the prescaler. If there was no prescaler, each clock cycle would increase TCNT0. As you can see, it will take a lot of cycles to get TCNT0 to 200 and see the service routine in action, but eventually you can get there.

So thats about all I'm going to get into. Of course there is a lot more to this subject but this at least illustrates one example.

STK 200 - blinky lights

2011-06-04T13:07:00.000-07:00

* update: I wrote a revised version of this guide using AVR Studio 5. It uses the same code but I added new photos and wording. Check it out: STK 200: First Program (LED Blink)

As I mentioned previously, I was initially frustrated when I tried to program the STK 200 from Kanda because of the lack of documentation. So I thought it would be helpful to post some of my experiences. To start off, I'll explain the way I loaded a super simple, blinky lights program.

So lets assume you just got the kit in the mail and you have not done any AVR programming in the past. Lets start by installing some software. Go to the Atmel website and download AVR Studio 4 (you will have to register but it is free). Atmel released AVR Studio 5 beta in March 2011 but as of now I still use AVR Studio 4 because of the extensive support for it. Next go to the Kanda website and download their AVRISP-U software. Finally, we need AVR GCC (C Compiler). So you can check out the WinAVR website for a link to the download page or just go the WinAVR sourceforge page and find the latest stable release.

So what do we actually want our program to do? Our objective is to simply cause the built-in LEDs to blink. If you look at the kit, there is a row of 10 LEDs numbered from 0 to 7 then "ISP" and "ON." Looking along the edge of the board, there is a row of "PORTS" and across from "PORTB" there is a 10 pin header named "LED'S". We need to connect PORTB to the LED header using the supplied ribbon cable. I marked the two locations on the picture below:

STK 200: LED Layout

This is a good time to point out that on the above picture, I switched my stock ATmega8515 with an ATmega32 which I ordered. For this program, everything, including the code is exactly the same for both. However, for complex programs, you might need more memory or functionality which the ATmega32 could provide. If you are interested in switching your microcontroller, check out my "switching microcontrollers" post (link). And in this blog post, whenever you see ATmega32, replace it with ATmega8515 if you are using the stock STK kit.

Assuming all of the software is now installed, go ahead and open AVR Studio 4. You should see the following screen (except there will be no recent projects):

Pick the New Project option. Now choose "AVR GCC" as the Project Type, "blink" as the project name and make sure that both the "Create Initial File" and "Create Folder" boxes are checked. It should look like:

Finally, click next and select "ATmega8515" from the list of devices on the right side. Click finish and you are finally ready to write some code!!

Essentially, PORTB is an I/O port which will control the LEDs. So our code will just tell PORTB to send out alternating OFF/ON signals. Here is the C code I would write:

#include <avr/io.h>
#include <util/delay.h>

void delay_ms(unsigned int d)
{
    _delay_ms(d);        //make delay portable
}

int main(void)
{
    DDRB=0xFF;          //PORT B (LEDs) output
    while(1)
    {
        PORTB=0x00;     //LEDs ON
        delay_ms(1000); //delay
        PORTB=0xFF;     //LEDs OFF
        delay_ms(1000); //delay
    }
}

I should mention that using the built in delay function is probably not the best idea. I'm using it here because it makes the code look really clean and you can adjust the delay time very easily. You simply write delay_ms(x) where x is the number of milliseconds of delay. The way you should actually do delay is using interrupts but that is a whole other subject. So this works for now. One unfortunate side effect is that he AVR simulator (debugger) in AVR Studio 4 does not always work with the delay library. If you are getting a dialog box that asks you to "please browse to the present location for files originally found at c:\blah blah", you're not alone. But anyway, once you've entered the code in AVR Studio, hit F7 to build the program. As long as you have no errors, you are good to go. Now, lets get set up to program the microcontroller.

Look at this picture to get an idea for the connections:

Basically, there is one connection with the ISP from your computer to the board and another connection with the ribbon cable between the LED Header and the PORT B Header. Both of the cables are provided with the kit.

Next, open the AVRISP-U program on your computer and at the bottom of the window there should be green light and something saying that the device is recognized. If there is a red light, hit the reset button on the upper right and see if that works. Here is a screenshot of the program:

Then, on the top menu, File>Load>Flash... and browse to the "blink" folder you created when you started in AVR Studio. Once you are in the blink folder, open the folder named "default" and you should find a file named "blink.hex". Load this file. Then do Device>Erase. Next Device>Program>Flash. And finally Device>Run.

And thats it! All 8 of the LEDs should be blinking on and off at a reasonable rate. Hopefully it helps somebody getting started with the kit.

Also check out my other STK 200 posts:

Switching microcontrollers: http://nickweil.blogspot.com/2012/01/stk-200-switching-microcontrollers.html

Getting started programming: http://nickweil.blogspot.com/2012/02/stk-200-getting-started-programming.html

STK 200

2011-05-22T21:37:00.000-07:00

This semester I used the STK 200 from KANDA as an AVR trainer kit. At first I found the kit to be extremely frustrating but it has started to grow on me. I continue to discover useful features built into the unit but these discoveries underline the reason I was frustrated in the first place: there is extremely poor documentation for the kit. After spending countless hours trying to utilize the onboard LCD pins, I stumbled upon example code on the KANDA website which allowed me to understand the pin controls. Perhaps I can detail some of the difficulties I had to work through in future posts and save others the hassle. The good news is that once you understand how to use the kit, it proves to be very robust and handy.