Joel's iFoundry Blog

Reflection

2009-12-17T17:26:00.000-06:00

If your screen is glossy enough, it's quite easy to reflect. Simply click this black square and look into your screen.

The actual content of this post happens when you click the "Read more" button.

Sorry. That was the wrong kind of reflection. According to Dictionary.com, reflect (not to be confused with genuflect) means to think, ponder, or meditate, and I'll be using that definition for the remainder of this post as I reflect upon this past semester, what went well, what didn't go well, and the stuff I just wasn't there for.

At the beginning of this semester, I had no idea what iFoundry was. Due to a communications mix-up, I didn't even know whether I got in or not. Then came the iFoundry orientation (iLaunch) which, while it was a lot of fun, I left still somewhat confused as to what iFoundry really was. Sure, I learned that it was designed to create more well-rounded engineers by teaching something called the "missing basics", and that someone really likes affixing lowercase i's to the beginning of nouns, but I didn't know how we were going to do that. Actually, at that point, I doubt anyone really knew what we were doing--not even the professors--since the professors pretty much told us, "we'll do what you want to do."

I guess at this point, I should probably clarify what iFoundry is. iFoundry is a new organization (started this year) within the engineering department of the University of Illinois. It is dedicated to transforming the engineering curriculum to better prepare engineering students by giving them a greater breadth of knowledge in the areas outside of math and science which are necessary to be successful in the workplace. Judging from the fact that I can actually define iFoundry, I'd say I am no longer confused.

The professors gave us a framework for meeting and making decisions, but it was up to us figure out what we would do and how we would do it. We iFoundry students split up into four groups based on what we wanted to do. I joined the group "Art and Engineering Design", because I like art, and I like design, and I like engineering. After choosing our iChair (which, in any normal organization would just be called a "leader"), we decided upon some of the things we wanted to do. One thing a lot of people wanted to do was a project of some sort. After all, we are the art and design group--shouldn't we, you know, make something? Despite the huge interest, it took almost a whole semester to decide what to do, so we haven't actually done a project yet. Except, we did. As part of the in-class portion of iFoundry, we were put in groups of five and given an Arduino, $100, and a few weeks to decide what to do with it. As you can see on this blog and here, we came up with some pretty interesting and fun projects. Before that, we built steam powered cars out of tin, soda cans, and various other iDoodads (I am well aware that that is not a word. I also don't care. :P). Here's what I think of those two projects:

I must return to studying, so I'll cut this a little short. We took a field trip to SOM to check stuff out, but I had an unavoidable class that day, so I couldn't go. We also talked with Gerry LaBedz from Motorola quite a bit, which was both entertaining and very informative. I must go. Goodbye!

Morse Code Arduino Sketch

2009-12-12T15:51:00.002-06:00

I've uploaded the Arduino sketch for the Morse code translator here:
http://chaosinacan.x10hosting.com/media/code/morse.zip
It is fully commented, so hopefully it isn't too difficult to figure out. If it's confusing, just ask me and I'll try to explain it.

Also, if you want to try this project out, this is the circuit diagram for the entire translator. The potentiometer at the center right was used to control the backlight level, but I replaced it with a setting in the code, so you can ignore that part. If you're unfamiliar with the symbol, the component on pin 12 is a piezo buzzer. Everything else should be labeled.

More stuff, like a component list after the break...

Here is a list of the components you will need and links for the more specialized components:

An Arduino Duemilanove - The kit at http://oomlout.com/ards.html also comes with the breadboard, piezo buzzer, switches, resistors, wires, and photoresistor. If you already have all that stuff, you can get one at Sparkfun too!
A square force-sensitive resistor - Sure, you could use a switch instead, but that's no fun.
A serial enabled 16x2 5V LCD screen - If you use something other than the Sparkfun screens, you will probably need to modify the Arduino code.
A small photoresistor
A piezo buzzer
2x momentary pushbutton switches
4x 10,000 Ohm resistors

When the translator powers up, it loads settings from its EEPROM. The first time you start it, nothing meaningful is stored in EEPROM, so it could load gibberish or just 0 into all of its settings. If this happens, you should be able to get into the menu and do a reset, which will fix this problem forever. If you can't, comment out the "loadSettings();" on line 60 of morse.pde, run the program, and do a reset.

I should probably explain how the menu works too. The two pushbutton switches act as Left and Right buttons and the force sensor you tap Morse code into acts as the Enter button. Press either the Left or Right button to enter the menu. You can also quickly exit the menu by pressing both Left and Right at the same time. You navigate through the menu using the Left and Right buttons and make a selection by pressing Enter. If a number appears, you can edit it by pressing/holding the Left or Right buttons and finish editing by pressing Enter. If a question appears, like "Reset All?", you choose one of the two answers at the bottom with the Left or Right buttons.

Have fun!

More Pictures

2009-12-12T13:58:00.005-06:00

...or, should that be, Morse Pictures. Hahahaha... no.

Here's a few more pictures of the Morse code translator, starting with some outside shots. We bought some gears thinking we would be making something else, but when that didn't work out, we decided we needed to use the gears for something. Now our enclosure looks like one of those things you used to make in Kindergarten by gluing macaroni to stuff...

More pictures after the break...

There is a menu system that lets you adjust the timing and backlight level. The two buttons in this hole are used to navigate it. We wanted to stick them on top, but we couldn't find a way to mount them.

The slightly shiny thing inside the hole is a photoresistor. It is used to automatically adjust the screen's backlight brightness as seen in the second video here.

The top layer of the enclosure where the force sensor and LCD screen are mounted. This whole thing is literally held together by cardboard and duct tape.

Inside the box. The circuit is pretty simple since the Arduino microcontroller does all the work.

Morse Code Translator in Action

2009-12-11T16:27:00.000-06:00

A video of the Morse code translator in action. Apparently, I fail at entering exclamation marks. The screen's backlight automatically adjusts to the brightness of the room, shown in this next video.

Reading Morse Code with an Arduino

2009-12-09T22:17:00.003-06:00

For part of my ENG 198 class, we were put into groups of 5, given an Arduino microcontroller and a $100 budget, and told what was effectively, "make something." My group decided to make a balancing robot. Then the parts we needed were on 2-3 weeks backorder, so we decided to go with plan B--just as soon as we could figure out what that was. Eventually, we decided to make a box that you could tap Morse code into, and it would convert it into text and display it on a small LCD screen.

This is what happens when you use part of your budget on gears for a robot... then you build something that isn't a robot. Anyways, ignoring the last-minute cardboard enclosure, there's a serial-enabled LCD screen at the top, a force sensor at the bottom, and the hole on the left is for a photo-resistor that adjusts the backlight brightness. I'll post a video of it in action later along with some photos of the inside, but what I really want to talk about is a simple algorithm to interpret button presses as Morse code. The Internet is full of examples as to how to turn dots and dashes into letters, or letters into dots and dashes, but I couldn't find anything on getting those dots and dashes in the first place.

More after the break...

The code here uses the Arduino libraries, but it's really just C/C++. millis() returns the number of milliseconds elapsed since the Arduino was switched on, and I'll be using that for timing. digitalRead(pin) returns the state of the digital input on the microcontroller (HIGH or LOW). The logic goes something like this:

If the switch gets pressed, record the time it became pressed
When the switch gets released, record the time it was released and this to the time it was pressed to get the length of the switch press.
If this time is less than some threshold, a dot was entered, otherwise a dash was entered.
When the switch is unpressed, compare the current time to the time the switch was released to get how long it has been unpressed.
If this time is longer than some small threshold, take all the dots and dashes recorded and translate them into a character. Print it, clear the record of dots and dashes, and remember that we already printed a character so we don't do it again until more Morse code is entered.
If the unpressed time is longer than some larger threshold, this is a break between words. Print a space and stop checking for spaces and character breaks (steps 4-6).
If the switch gets pressed again, we can start looking for spaces and character breaks again.
Goto step 1.

Here's the code. I'll leave it to you to decide how to remember the Morse code and translate it to text, but this will get you the dots and dashes:

//The digital pin the switch is on
#define SWITCH_IN  0
//If the switch is held longer than this, it's a dash
#define DASH_LENGTH  200
//If the switch is left unpressed longer than this, it's a
//character break.  
#define BREAK_LENGTH 220
//If the switch is left unpressed longer than this, it's a space
#define SPACE_LENGTH 900

void loop()
{
 //The time the switch was last pressed
 static long onTime = 0;
 //The time the switch was last released
 static long offTime = 0;
 
 static bool lastSwitch = false;
 //Current switch state
 bool switchState = digitalRead(SWITCH_IN) == LOW;
 //Was switch pressed this loop?
 bool switchPressed = switchState && !lastSwitch;
 //Was switch released this loop?
 bool switchReleased = lastSwitch && !switchState;
 //Update last state for next loop
 lastSwitch = switchState;
 
 //Keep track of these so we don't keep printing spaces
 //over and over again:
 //Have we already printed a space?
 static bool spaceEnded = false;
 //Have we already printed a character and moved on?
 static bool breakEnded = false;
 
 
 if (switchPressed)
 {
  //Record the time the switch was pressed
  onTime = millis();
  //When the switch is pressed, reset whether character
  //breaks or spaces have already been printed.
  spaceEnded = false;
  breakEnded = false;
 }
 else
 {
  //Record the time the switch was released
  offTime = millis();
  //Compare the on and off times to get the length of
  //the switch press, then check to see whether that was
  //a dot or a dash
  long pressLength = offTime - onTime;
  if (pressLength > dashLength)
  {
   //A dash was entered
  }
  else
  {
   //A dot was entered
  }
 }
 
 //If the switch is unpressed and we haven't printed a space yet,
 //check to see if we should.
 if (!switchState && !spaceEnded)
 {
  //Compare the current time and the off time to get the time the
  //switch has been unpressed, then check to see whether we should
  //print a space or character
  long waitLength = millis() - offTime;
  if (waitLength > spaceLength)
  {
   //A space was entered
   spaceEnded = true;
  }
  else if (!breakEnded && waitLength > breakLength)
  {
   //Done entering a character.  Parse the dots/dashes and reset
   breakEnded = true;
  }
 }
}

I will post the full source code of the project later.

The Pen is Mightier than PowerPoint

2009-09-28T20:12:00.001-05:00

I have nothing against Microsoft or PowerPoint (or blind people), but it's often easier, faster, and more effective to explain things with a pen and paper. Part of the reading for the University of Illinois' iFoundry class is Dan Roam's "the Back of the Napkin", which shows how to use pictures to solve problems. After attending a lecture by none other than Dan Roam, I can say that a visual representation of a problem definitely helps to understand the problem. All of us are visual thinkers. Paraphrasing Mr. Roam, if you have the ability to walk into a room without running into something, you already have the ability to solve problems with pictures. (For the rest of you, I'm not sure what to say.)

What's wrong with PowerPoint then? Unless you have a tablet PC or are incredibly skilled with a mouse, programs like PowerPoint only serve to limit your creativity. Actually, it isn't really PowerPoint's fault. PowerPoint makes it simple to build bulleted lists, fancy charts, and pretty effects, but it is often so easy to focus on the presentation of an idea rather than the idea itself. Presentations with nothing but text and bullet points aren't all that effective either. Have you ever tried reading a book and listening to someone at the same time? It's not so easy to focus your language facilities on two things at the same time. On the other hand, if you can walk and talk to a friend without running into anything, you can listen and understand pictures at the same time. In short, pictures can supplement a presentation without detracting from it. For a great example, take a look at Mr. Roam's explanation of what went wrong with American health-care.

I'll end this with another interesting tidbit: Take a look at these two pictures from hazardouspaste.com and XKCD, respectively.

Both flowcharts express similar ideas. Which one draws your attention more? The hand drawn one right?

Testing

2009-08-27T19:07:00.000-05:00

This is a test. This blog is conducting a test of the Emergency Blogging System. This is only a test.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget leo elit, in placerat nunc. Nulla id elit vitae orci lobortis posuere. Integer lacinia eros et lectus accumsan ut fermentum arcu varius. Integer sagittis diam ac justo ultricies blandit. Nunc vestibulum convallis molestie. Nulla semper interdum sapien, in aliquet ligula lobortis non. Ut vitae molestie sapien. Nam lacinia est dui. Nullam tincidunt mattis imperdiet. Nam et dui felis. Vivamus non dictum est. Maecenas iaculis lacus vitae justo commodo consectetur tincidunt nisl pulvinar. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Pellentesque non volutpat lacus. Aenean tincidunt pretium mi, eu consectetur ipsum adipiscing sed.

This is a test of the Emergency Blogging System. The bloggers of your area in voluntary cooperation with the Federal, State and local authorities have developed this system to keep you informed in the event of a blog post. If this had been an actual blog post, the Lorem Ipsum you just read would have been followed by official information, news or instructions. This blog serves the Champaign-Urbana area. This concludes this test of the Emergency Posting System.