Robot Assignment 5: Morse Code

Before the invention of the two-way radio, messages were transmitted using Morse Code, which used patterns of flashing lights or audio beeps to represent different characters in the alphabet. For example, the "beeeeeeep beeeeeeep beeeeeep beep beep beeeeeeeep beeeeeeeep beeeeeeeeep" sound that some cell phones make when an SMS is received is actually the Morse Code for the letters "S", "M" and "S"! Similarly, the series of beeps that the TV station plays before their news broadcasts is also a Morse Code message.

Your Task

This assignment will not involve any mechanical tinkering on the part of your robot, or moving about for the jacket wearers. All that you will need to do is to use the light sensor (jacket groups, your i*CATch main board has a light sensor onboard) to receive an encoded message and to print out the decoded string onto the monitor.

Detailed specifications are as follows:

• You will receive your Morse Code message through this web site. Test it out by typing in a short string, the box should flash black and white. If you hold up your light sensor to the monitor screen, the flashes will be received by the light sensor as bursts of light.
• Morse code transmits characters using dashes and dots. For us, a long flash of white is a dash, a short flash is a dot. In addition,
• One unit will be 400 milliseconds long (1000 milliseconds = 1 second)
• One dot is one unit in length.
• One dash is three units in length.
• Between each dot and/or dash in a single character, there is a gap of 1 unit. For example, the code for the character "A" is ._. The signal would then be 1 unit of light, 1 unit of darkness, then 3 units of light.
• Between each letter in the same word, there will be a gap of 3 units.
• Between the last letter of a word and the first letter of the next word (e.g. between words), there will be a gap of 7 units.
• Morse code has patterns for lots of characters. For this assignment, however, we will only be using the following characters:
  • the alphanumeric characters.
  • The "begin of transmission" marker (_._._)
  • The "end of transmission" marker (._._.)
  . Therefore, the signals for a complete message would be: begin-transmission (gap of 7 units) pattern-for-message (gap of 7 units) end-transmission
• Your program is required to decode the entire message before printing it out.

Freebies and Hints

This is by far the most complex problem that you have encountered so far. Therefore, we're giving you some help:

1. General Algorithm

Since this program is fairly complex, we're going to give you the general algorithm to solve this program:

1. Initialize an accumulator (let's say we call it code) to store the dots and dashes.
2. Initialize another accumulator (let's say we call it message) to store the decoded message.
3. Set a sentinel (let's say we call it done), that will have the value of True when the message has been fully received.
4. Wait for a flash of light. Record the time. This is the priming read.
5. While done is False
1. Wait for the light to go off. Calculate the length of the flash of light.
2. If it's a dot (you know how to check this, right?)
   1. Add "." to code
   Else, it's a dash.
1. Add "_" to code
3. Wait for the next flash of light. Record the time
4. Calculate the length of the gap in between the two flashes of light.
5. If the time is an inter-character gap or an inter-word gap, then what you have in code corresponds to a character:
   1. Decode the character
   2. If the character is the end of transmission marker
      1. Set done to True
      else
   1. Add the character to message.
   2. Reset code to the empty string
   3. If the time is an inter-word gap:
   1. Add a space to the end of message
6. Print out the entire message

That's the general algorithm. It's just a suggestion, you can try your hand at coming up with your own algorithm if you want.

2. Waiting for the light to turn on/off

In the algorithm, there are several places where the program is supposed to wait for the light to turn on. You can do this using a while True loop:

while True:
    if the light sensor detects light
           break
Process the light signal

Something very similar can be used to wait for the light to turn off.

3. Calculating the length of a flash of light

To decide whether a flash of light is a dot or a dash, you will need to time it to see how long it has been on for.

You will need to make use of the timing capabilities of the computer. Python gives us a time module that has the time.clock() function that you will find useful. time.clock() returns a floating point number that represents the time elapsed (in seconds) since the program started running.

Therefore, suppose that you need to time the length of operation A. You can use this general algorithm:

startTime = time.clock()
do Operation A
elapsedTime = (time.clock() - startTime)

Note: time.clock() does not work as well on Mac or UNIX machines as it does on Windows machines. But don't worry -- on those operating systems, you can use time.time() instead, which will do something similar. Just remember that your demo will be on the lab machines, which run Windows, so change it back to time.clock() and test it out before you hand in your program!

Specifications, Deadline and Evaluation

Your program should be called MorseCode.py.

Together with your program, we're going to request that you hand in a brief report describing your work in English. This report should not be more than one page long, and it should include the following parts:

• Your algorithm (in English, obviously)
• How you tested your program at home (or in the lab)
• What weak points do you think your program has, or where you think that your program might fail.

Your program will be evaluated in two ways: through your code, and also through a demonstration. Therefore, you will need to hand in your program to WebCT, as well as to demonstrate it to the TA.

The deadline for handing in the code is 07:00, Thursday December 3, 2009. No late submissions are allowed. The person in the group with the smallest studentID should hand in the code. If we get multiple submissions in the group, we'll just pick the one with the smallest studentID and ignore the rest.

For the demonstration, you are to sign up for a time slot. During the demonstration, you will first demo your program running to your TA. He will watch your program do its task, and then will ask you some questions about your program. He might also choose to do a "wire-pull test" -- which is, the TA will make some changes to your code when you're not looking. Then you will have to debug your program in front of him.

Bear in mind that the TA can ask anybody in your group to do the demo, or to debug the program. He/she also has the right to ask the rest of the groupmates to leave the room while the program is being demoed. Therefore, everybody needs to be present for the demo.