Arduino Intro Labs for Tangible Computing
3. Introductory Lab - Flashing Lights and Morse Code




3.1 Arduino Programs

In this first lab we will demonstrate the Arduino development environment for writing programs. These programs are then loaded into the Arduino where they are run. The easiest way to introduce the Arduino environment is with a demonstration. More details on the features of the environment are described at the Arduino HomePage. There are other tutorials to help you get started after you complete the labs here.

If you have programmed before, you might find Arduino programs a bit strange, in that they never stop. A program will keep running until you remove power from the circuit. When you apply power again, it will restart at the beginning. Note, each board has a reset button that achieves the same effect as removing power, namely, restarts the program from its initial starting state.

Every programming environment has a Hello World example which is used to illustrate the minimal interesting program. For the Arduino this consists of flashing a LED.

3.2 Building Circuits & Kinds of Pins on the Arduino

The Arduino has 3 kinds of pins on the board. The power pins (top left) are used to provide power to the devices that are connected to the Arduino. All we care about are the 5 V (five volt positive) and 0 V GND (ground) pins. Until you know more, do no connect anything up to the other pins (such as the 3.3 V and Vin).

Note: Even though this is an image of the Uno, the wiring is the same for the Mega. Click the image to view the full size.



Hint: Modern breadboards are easy to use. There are specially designed patch wires which are flexible but have rigid pins on the end to make them easy to plug into the board. If the breadboard is fairly new the wires will not go in easliy, so don't be afraid to use some force to get the wires into the breadboard. If that isn't working you can try a pin above or below it.

Warning: Do not connect the +5 V bus directly to ground! This creates what is called a short circuit and can damage the circuit. Fortunately the Arduino has some protection against this, so it will not be damaged by a short that only lasts for a few seconds.

Need help wiring? Here's a section on how to building a basic circuit.

Notice how there is no keyboard, mouse, or screen. The computer is the large square "chip" in the middle of the blue circuit board. At the top is a USB connection (silver reactangular box) to a "normal" computer that is used to program the Arduino, and to give it power. Around the edge of the blue circuit board are black connectors that you plug wires into. This is the Arduino's interface to the outside world. These are called interface pins. In the lower middle is the reset button which is used to reset the board if it gets stuck, or if you want to restart your program that is running on the Arduino.

The Breadboard: The white block with holes in it is called a breadboard. It is used to build small circuits that connect to the Arduino interface pins. The board is divided into 4 regions, left to right.

The two outermost regions have a red and blue vertical line. These are called power buses. All of the pins in the red column are connected together, as are all of the pins in the blue column. Normally, the red column is the positive (+) power bus and the blue column is the negative (-) or ground bus. The Arduino can be used as a power source. If you look carefully at the wires, there is a red wire running from the Arduino pin labelled 5V to the left hand positive power bus, and a black wire running form the Arduino pin labelled GND to the left hand ground bus.

Principle: In a circuit, electric current flows from higher potential locations to lower potential locations. Potential is measured in Volts (symbol V), relative to some ground point. This is similar to how we measure altitude. Altitude is your height in meters relative to the ground. But what we choose as ground depends on our needs. Airplane and mountain altitudes are measured relative to sea level. Parachutists measure altitude relative to the ground they are going to hit. The positive bus in our circuits is at +5 V compared to the ground at 0 V. In some circuits there are potentials below ground, in which case they will have negative voltages.
The two innermost regions are divided by a vertical groove. Each of the 5 pins in a horizontal row are connected together. These rows are used to make connections for the components of your circuit. The grove down the middle lets you plug in more complex components, many of which are integrated circuits.

The most common pins are the digital I/O pins, numbered 0 to 53 on the Arduino Mega and 0 to 13 on the Arduino Uno. These pins are used to send binary data (0 and 1) between the Arduino and the outside world. These pins can be configured as input mode (that is, to read from the outside world), or as output mode (that is, to write to the outside world).

Digital pin 13 also has a small green LED on the board attached to it. It is labelled L on the circuit board, and is adjacent to digital pin 13. The other form of pin is the analog input. These are labelled A0 to A15, and appear on the left side of the circuit board of the Arduino Mega and pins A0 to A5 on the Arduino Uno. We will get to these later.

There are special digital pins that you should avoid until later: pins 0, 1, 14 to 19 are used for serial communication.

3.3 Part 1 - Blink the LED on Pin 13

The outcomes of this part are:
  1. Know how to start the Arduino environment, with a properly connected Arduino board.
  2. Be able to enter in a program, compile it, and upload it to the Arduino board.
  3. Know the parts of an Arduino program (called a sketch in the Arduino vernacular). A sketch is a program that has as a bare minimum two procedures named setup and loop.
  4. Understand that the setup procedure is called once, and the loop procedure is called as often as possible. The moment that it returns it will be called again. Thus an Arduino program keeps running until you reset the computer.
  5. Be able to write a program to manipulate the digital output pin 13 connected to the onboard LED.
  6. How to look up these details in the Arduino documentation.
Start a new program by opening the Arduino IDE, and go to Tools in the menu bar and select the proper Board (Mega 2560 or Uno) and Serial Port (such as /dev/ttyACM0).

Here is a demo of how to use the IDE to compile and load the program below:

Watch the video: Lab01Part01Compile.mov

Then type in or paste the following code. If you are typing, to save some time, you can skip the comments. These are the lines that begin with //, or are between (and including) the start comment symbol "/*" and end comment symbol "*/". Note, punctuation is important so type in exactly what is written. In the Arduino IDE, the comments will appear in a grey font. Typically IDEs will use colour coding to make it easier to distinguish important pieces of the program from each other. If you are not typing, then read through what you have just pasted! Again! Often a paste will miss important leading or trailing characters.

code/Lab_SOS/SOS01/SOS01.ino

    // the onboard LED is attached to pin 13
    int ledPin = 13;
     
    /*
        When the Arduino board is reset, this method is 
        run exactly once.  Its job is to put the board into
        the proper configuration.
    */
    void setup() {
      // configure ledPin to be a digital output
      pinMode(ledPin, OUTPUT);
    }
     
    /*
        An Arduino program is generally not meant to stop.
        It is supposed to keep interacting with its environment.
        The loop method is run over and over until the power
        is removed from the board, or the board is reset.
    */
    void loop() {
      // set the pin to output a HIGH value and turn the LED on
      digitalWrite(ledPin, HIGH);
     
      // wait for 1000 milliseconds
      delay(1000);
     
      // set the pin to output a LOW value and turn the LED off
      digitalWrite(ledPin, LOW);
     
      // wait for 1000 milliseconds
      delay(1000);
    }


How to upload your program: Compile ('Verify', the Checkmark button) and upload your program (the right pointing arrow). We will explain these two terms later. The Tx and Rx lights should flash, and then turn off. At this point the LED should start to flash.

Not working?
  1. Make sure the program is uploaded properly.
    1. Do the Tx and Rx LEDs flash during upload?
    2. Is the USB cable plugged in?
    3. Is the proper Serial Port selected in the Arduino IDE?
    4. Is the proper processor type (Mega 2560 or Uno) selected in the IDE under Board?
  2. Hardware issues?
    1. Try pressing the RESET button on the blue circuit board.
    2. If not, try choosing new wires since it is possible that some may not work anymore.
This program illustrates the following key concepts:
Concept: A program is composed of different kinds of parts. Some parts are used to declare things, such as the name and type of a variable. Other parts perform actions, such as invoking the procedure that turns on the LED.
Concept: A variable is an item of data in a program. Most variables have names (or identifiers). Every variable has a value. As the program runs the value of a variable can change. Variables can store values that have a specific kind of types, for example integer or character.

A variable must be declared before the program can use it. The declaration gives: the name of the variable, its type, and possibly an initial value. For example, the statement
int ledPin = 13;
declares a variable called ledPin which is of type int (an integer number between -32768 and 32767), and gives it the initial value of 13, which indicates which pin the LED is hooked up to. The semi-colon (;) at the end is important because it signifies the end of the declaration.
Concept: We can take a sequence of program statements and place them into a named collection called a procedure. We can then perform these statements at a specific point in the program by using a procedure invocation. Procedures can have parameters and return a result. For example, the statement:
digitalWrite(ledPin, LOW);
invokes the digitalWrite procedure (that is defined elsewhere) with two parameters. Procedures can be identified by having two parentheses following the name of the procedure such as delay(). If a procedure requires parameters they are placed inside the parentheses, each one separated by a comma as shown with digitalWrite(). Procedures can also be called methods, functions or subroutines. The parameters are one way to pass information to the procedure, and the result is one way to get information out of the procedure. There are other ways.

The first parameter in the statement above is ledPin which says which digital I/O pin to use (recall that ledPin has a value of 13, the pin the LED is connected to), the second parameter is LOW which means the low output value. The result is to set the output of the pin to the LOW value. The procedure does not return a result.


3.4 Part 2 - Build a circuit with an external LED

The outcomes of this part are:
  1. Be able to interpret a simple circuit diagram and build it on the breadboard.
  2. Be able to perform simple trouble diagnosis and correction when things do not go right.
Use the same program as Part 1, but now add some external circuitry. Wire up the board as shown in the photos below.

Quick Wiring Tips!
  1. The longer LED lead is the positive, so it goes to the wire and short lead goes to the resistor. The wire goes to Pin 13.
  2. Remember to use the 'Green-Blue-Brown' resistor for the LED!
  3. Looking for more information on the LED and resistor?
Arduino Mega Arduino Uno
Click the image for full size!


Not working?
  1. Make sure the program is uploaded properly.
  2. Make sure you have the proper wiring:
    1. Arduino 5 V to Left + on breadboard?
    2. Arduino GND to Left - (GND) on breadboard?
    3. Arduino Pin 13 to the breadboard row 1, left side of the division? (BB Left 01?)
    4. Make sure the LED is connected correctly. Long leg to + and short leg to the resistor.
    5. Resistor to row 2, left side of the breadboard and to the column of ground pins on the left side as well? (BB Left 2 to BB Left GND?)
In this circuit, there is a yellow wire connecting Arduino pin 13 to breadboard left pin 1 (BBL01). Breadboard left pin 2 (BBL02) is connected to the ground bus. The remainder of the circuit consists of a resistor and a light emitting diode (LED).

Resistor: The resistor has a color code on it that specifies the value of the resistor. (See resistor color code) In this case the code is Green Blue Brown, which means 560 Ω. The Ω is the sign for Ohms, which is a measure of resistance. The purpose of a resistor is to limit the amount of current that can flow in a part of a circuit.
Principle: The amount of current flowing in a circuit is measured in Amps (symbol A). Current, voltage, and resistance are related by the relationship
E = I R
where E is the potential difference measured in Volts, I is the current measured in Amps, and R is the resistance measured in Ohms.
Light Emitting Diode: The LED is the common replacement for the incandescent light bulb. (See LED). LEDs comes in various colors. There are two very important things to remember about LEDs.
Reality Check: In our circuit, the voltage E is 5V, the resistance R is 560 Ω, and so the current I is 5 / 560 = 0.009 A. Or, since we typically have small currents in our circuits, the current is 9 mA (milli Amps). Why do we have a resister in series with the LED? The resistance of the LED when it turns on is very small, so without a resistor the current that flows is large, and the resulting energy will burn out the LED. A typical LED should not have a current above 20 mA. So 9mA with our resistor is safe.


3.5 Part 3 - The Potentiometer

The outcomes of this part are:
  1. Understand how a potentiometer combined with analog input can be used for input.
  2. Understand the relationship between what the program is doing, and when it can interact with the environment.
  3. Be aware of interactions between your visual system and how you perceive output lights.
Concept: A potentiometer is a special kind of resistor. It has three pins. The outer pins are connected to the ends of the resistor. The middle pin is connected to a slider that moves between the ends of the resistor. If the outer pins are connected between +5 V and 0 V (GND), then the voltage on the middle pin will vary between 5 and 0 V, depending on whether it is closer to the 5V end or closer to the 0 end.


The potentiometer in the kit is 10kΩ, which means that the resistance between the outside pins is 10kΩ, and that the resistance between the middle pin and each ends pin varies between 0 and 10kΩ as you turn it. Whether it goes up or down when you turn it left or right depends on how the potentiometer is oriented to you.

If we connect the middle pin of the potentiometer to an analog input pin on the Arduino, then we can read the voltage on the pin as an integer value that varies from 0 (at 0 V) to 1023 (at 5 V).

With the analogRead function, the program can read the voltage and convert it into an integer value that is then used to set the delay time on the flashing light of Part 1 and 2. Keep the same wiring as before. All we are doing is adding a potentiometer. See the images below the code.

code/Lab_SOS/SOS03/SOS03.ino

        // the external LED is attached to this pin.
        // onboard LED is attached to pin 13, 
        int ledPin = 13;
     
        // slider of potentiometer attached to this analog input 
        int analogInPin = 0;
     
        // On and off time in milliseconds for the light
        int delayTime = 300;
         
        void setup() {
          // configure ledPin to be a digital output
          pinMode(ledPin, OUTPUT);
        }
         
        void loop() {
          // read the voltage on the analog input and convert
          // into an integer value in the range [0, 1023]
          delayTime = analogRead(analogInPin);
     
          digitalWrite(ledPin, HIGH);
          delay(delayTime);
     
          digitalWrite(ledPin, LOW);
          delay(delayTime);
        }
     
Arduino Mega Arduino Uno
Click the image for full size!


Concept: A procedure invocation can return a result. This result can appear in a statement. For example, the statement
delayTime = analogRead(analogInPin);
invokes the analogRead procedure on the pin whose number is the value in variable analogInPin. It returns the result (an integer from 0 to 1023) and this is then stored in the variable delayTime.


Questions to Answer:

  1. When you turn the potentiometer in one direction the speed of the flasshing goes up, and in the opposite direction the speed goes down. How do the power (red) and ground (black) connections on the potentiometer relate to the direction necessary to increase the flashing rate?

  2. When you turn the potentiometer to speed up the flashing rate, the LED appears to stop flashing. Then it suddenly gets dim. What is happening?

  3. When you turn the potentiometer, the flashing speed does not change immediately. Why is this happening?


3.6 Part 4 - The Pushbutton

The last piece of hardware that we introduce in this lab is the pushbutton. The pushbutton is a simple switch. When it is not pushed, the circuit between the pins is open (not conducting). When pushed, the circuit between the pins is closed (conducting). The digital input pins on the Arduino convert a voltage on the pin into a HIGH or LOW signal. A voltage near 5 V is considered a HIGH input, and a voltage near 0 V is considered a LOW input. A value in the middle is ambiguous.
Concept: If a digital input pin is not connected to anything, it is said to be floating. Reading from a floating pin is very unreliable. It might be HIGH, but can be LOW. So to ensure that a proper voltage is always present on a digital input, a pullup circuit is used. The resistor attached to the pin is called a pull up resistor. It's job is to ensure that the digital input pin has 5V present when the switch is open. Then when the switch is closed it pulls down the voltage to 0V. You can install the pull up resistor yourself. But this is such a common issue that the Arduino processor has built in pull up resistors that can be turned on. This is done in the setup code of the program.


The switch is attached as in the circuit described in the introduction. Just like before, simply add this circuit to the one you have already built that contains the external LED and the potentiometer.
Arduino Mega Arduino Uno
Click the image for full size!


Besides taking images of circuitboards, we can represent them as diagrams. The following diagram was drawn using the Fritzing program (Fritzing). There is also a circuit diagram (an abstract representation) of this circuit. Circuit symbols are standard, and described in many places. Here is what the final version of the SOS lab circuit looks like in both forms.
Fritzing Schematic
Click the image for full size!


Here is a simple program to turn the LED on or off when the switch is pushed and released.

code/Lab_SOS/SOS04/SOS04.ino

    // the LED is attached to this digital output pin
    int ledPin = 13;
     
    // the pushbutton is attached to this digital input pin
    int buttonPin = 9;
     
    // the value read by the pin.
    int buttonValue;
     
    void setup() {
      // set ledPin to OUTPUT
      pinMode(ledPin, OUTPUT);
     
      // set buttonPin to INPUT and 
      // turn on internal pull up resistor 
      pinMode(buttonPin, INPUT);
      digitalWrite(buttonPin, HIGH);
    
     
    void loop() {
      // read the pushbutton state
      buttonValue = digitalRead(buttonPin);
     
      // and set the light to be the same value
      digitalWrite(ledPin, buttonValue);
    }
     


Not working?
  1. Make sure the proper program is uploaded properly.
  2. Make sure you have the proper wiring:
    1. The switch should have the pins coming out of the left and right sides, not the top and bottom when properly placed on the breadboard.
    2. A way to test this is to place the pushbutton on the breadboard just as shown in the wiring diagrams. Only when the pushbutton is placed correctly will it span over the gap easily between the division of the two halves of the breadboard.


Question: Why does pushing the button turn the light off?

There is a fix to that problem. To do this task we introduce a new programming statement, called a conditional.

Concept: The if statement is used to make decisions, and change the behaviour of a program. The if statement comes in two forms

if ( logical expression ) {
    block of statements to perform when logical expression is true
}
else {
    block of statements to perform when logical expression is false
}


or if there is nothing to be done in the false case:

if ( logical expression ) {
    block of statements to perform when logical expression is true
}
Almost anything that is proper code can appear inside the block of statements, including additional conditional statements. This is called nesting and it is very important when you only need the first condition to be true and other times you need the first condition and an additional condition to both be true. This will become important in another lab.
To make a decision you need to determine if something is true or false, using a logical expression.
Concept Logical expressions are typically comparisons, like or expressions that result from combining comparisons using the logical operations of AND, OR, and NOT which you may or may not have seen before. The code below demonstrates how conditional statements can used. Here we used a conditional statement to turn the LED light on when the button is pressed:
if ( buttonValue == LOW )
Otherwise, else, we know the button is not pressed and the lightState (LED) is LOW (stays off).


code/Lab_SOS/SOS04_Fixed/SOS04_Fixed.ino

    // the LED is attached to this digital output pin
    int ledPin = 13;
     
    // the pushbutton is attached to this digital input pin
    int buttonPin = 9;
     
    // the value read by the pin.
    int buttonValue;
     
    // the value to be sent to the LED
    int lightState;
     
    void setup() {
      // set ledPin to OUTPUT
      pinMode(ledPin, OUTPUT);
     
      // set buttonPin to INPUT and 
      // turn on internal pull up resistor 
      pinMode(buttonPin, INPUT);
      digitalWrite(buttonPin, HIGH);
    
     
    void loop() {
      // read the pushbutton state
      buttonValue = digitalRead(buttonPin);
     
      // if you want the light on when the pushbutton is pushed
      if ( buttonValue == LOW ) {
        lightState = HIGH;
        }
      else {
        lightState = LOW;
        }
     
      // and set the light to be the same value
      digitalWrite(ledPin, lightState);
    }
     
Reality Check: Because a switch is mechanical, it takes time to open or close. In addition, when it is making this transition it behaves in an unexpected way: the mechanical contacts bounce for a while EC_3.8 very short (less than a microsecond) or long (fractions of a second). What this means is that we can't reliably trust a simple digital input from a switch. We have to wait long enough to assure ourselves that the switch really has changed state. For more details, see http://en.wikipedia.org/wiki/Contact_bounce, and a fascinating article (to some) on bounce characteristics, http://www.ganssle.com/debouncing.htm. We will revisit this later when we work with the pushbutton again in the second lab.


3.7 Part 5 - Sending Morse Code With the Button

Morse code is a means for transmitting messages when all you can do is send or not send a signal (light or sound). It consists of gaps (no signal) and marks (signal present) of varying durations. The basic units of Morse code are Each character is composed of a sequence of dots and dashes separated by inter-element gaps. A word consists of a sequence of characters separated by short gaps.

The most famous word in Morse code is SOS. It is represented as
. . . - - - . . .
Try sending this using the pushbutton.

For more details, see Morse code.

3.8 Part 6 - Sending SOS With a Program

You now have all of the tools to write a program that repeatedly sends SOS. The one thing you need to consider is how long the basic dot element should be. For now, you can run the code below and watch the O in SOS be transmitted. Take note of how dotTime is used. If you would like you can create the S (you will need to do so anyways) or move onto the next section to see how we can reuse code to make life easier.

code/Lab_SOS/SOS06/SOS06.ino

     
        // the external LED is attached to this pin.
        // onboard LED is attached to pin 13, 
        int ledPin = 13;
     
        // slider of potentiometer attached to this analog input 
        int analogInPin = 0;
     
        // length of a dot
        int dotTime = 300;
     
        // even though we are not using it yet, make sure the
        // pushbutton is set up correctly
     
        // the pushbutton is attached to this digital input pin
        int buttonPin = 9;
         
        // the value read from the pushbutton
        int buttonValue;
     
        void setup() {
          // configure ledPin to be a digital output
          pinMode(ledPin, OUTPUT);
     
          // set buttonPin to INPUT and 
          // turn on internal pull up resistor 
          pinMode(buttonPin, INPUT);
          digitalWrite(buttonPin, HIGH);
        }
         
        void loop() {
     
          // send out an O: - - -
     
          // dash 1
          // a dash is 3 dots long
          digitalWrite(ledPin, HIGH);
          delay(3 * dotTime);
     
          // an inter-element gap is one dot
          digitalWrite(ledPin, LOW);
          delay(dotTime);
     
          // dash 2
          digitalWrite(ledPin, HIGH);
          delay(3 * dotTime);
          digitalWrite(ledPin, LOW);
          delay(dotTime);
     
          // dash 3
          digitalWrite(ledPin, HIGH);
          delay(3 * dotTime);
          digitalWrite(ledPin, LOW);
          delay(dotTime);
     
          // and a short gap between O and the next character
          delay(2 * dotTime);
     
        }
     


3.9 Part 7 - Using Procedures to Reuse Code

The outcomes of this part are:
  1. Be able to take sequences of statements that are repeated and collect them into a procedure.
  2. Take code (to set the dot length by reading the potentionmeter) from a previous program and reuse it in a new program.
In the program above there are repeated sequences of instructions to do the same thing. We can take these sequences and put them into a container, called a procedure that gives a name to the sequence of instructions, hides their details, and let's say more directly what it is that we want to do. For example, sendDash is a more obvious description of what we want to do than is a comment followed by the instructions that turn the pin on, delay, turn the pin off, and delay. This is an example of abstraction.

Procedures are in principle quite easy to define, we just need to give it a name, and then put a bunch of statements inside the body of the procedure. But there are a number of technical details that we have to worry about, such as how does the procedure know what variables are being talked about inside the procedure body? We will deal with this later. For the present, it is safe to follow the examples in the code below.

Here is a sample starting point. Complete the definitions of the various procedures and clean up the code to use the new procedures to send the S O S. Note that you could do an additional abstraction and write two new procedures sendS and sendO that are used to send the letters S and O.

code/Lab_SOS/SOS07/SOS07.ino

     
        // the external LED is attached to this pin.
        // onboard LED is attached to pin 13, 
        int ledPin = 13;
     
        // slider of potentiometer attached to this analog input 
        int analogInPin = 0;
     
        // length of a dot
        int dotTime = 300;
     
        // even though we are not using it yet, make sure the
        // pushbutton is set up correctly
     
        // the pushbutton is attached to this digital input pin
        int buttonPin = 9;
         
        // the value read from the pushbutton
        int buttonValue;
     
        // we take the code for sending dot and dash and put them
        // into two methods
     
        void sendDot() {
          // a dot is one unit long
        }
     
        void sendDash() {
          // a dash is 3 dots long
          digitalWrite(ledPin, HIGH);
          delay(3 * dotTime);
     
          // an inter-element gap is one dot
          digitalWrite(ledPin, LOW);
          delay(dotTime);
        }
     
        void sendShortGap() {
          // we assume that we are preceeded by an inter-element gap.
          // so that we have 3 dots of gap
          delay(2 * dotTime);
        }
     
        void sendMediumGap() {
        }
     
        void setup() {
          // configure ledPin to be a digital output
          pinMode(ledPin, OUTPUT);
     
          // set buttonPin to INPUT and 
          // turn on internal pull up resistor 
          pinMode(buttonPin, INPUT);
          digitalWrite(buttonPin, HIGH);
        }
         
        void loop() {
     
          // send out an O: - - -
          sendDash();
          sendDash();
          sendDash();
     
          sendShortGap();
        }
     


Modify your code so that it uses the analog input and potentiometer to control the length of the basic dot, thus making it possible to change the speed of the SOS transmission. Of course the speed will only change after a complete SOS signal has been sent, assuming that's you didn't change the length partway through the SOS transmission! You have now built an Emergency Beacon that sends out a distress signal.

Your tasks: Questions:

3.10 Other Things to Do

Was this too easy for you? Want a harder hardware challenge? Use the pushbutton as input for turning on and off the SOS signal. Turning off the signal is harder than it looks! Questions:

More LED fun:
3. Introductory Lab - Flashing Lights and Morse Code
Arduino Intro Labs for Tangible Computing / Version 1.00 2012-09-24