Introduction - the C Language, the Arduino Environment and the First Program

1Lab objectives

• Installing the Arduino IDE and configuring the board and the upload port
• Understanding the setup() / loop() structure and why it exists
• Identifying the functions of each pin on the Arduino Uno board
• Choosing data types suited to a system with 2 KB of RAM
• Driving an output pin and checking that it works with an LED

2Materials needed

• 1 Arduino Uno board (ATmega328P)
• 1 Type B USB cable
• 1 Breadboard
• 1 5 mm LED
• 1 220 Ω resistor
• 2 Jumper wires

3Board architecture

The Arduino Uno board is built around the ATmega328P microcontroller, an 8-bit processor with a modified Harvard architecture. Its resources are modest - and that is exactly why every programming decision matters.

4Pin explorer

Click any pin to see its functions. Notice that many pins have multiple functions - for example D13 is at the same time the SPI clock and the onboard LED, while D0 and D1 are used by serial communication.

5Program structure

An ordinary program starts, does its job, and ends. A microcontroller program never ends: as long as the board is powered, the processor must be executing something. That is why the Arduino environment requires two functions:

/* The two functions you write in the sketch: */
void setup() { /* YOUR initialization code */ }
void loop()  { /* YOUR code, repeated forever */ }

/* ...and the Arduino environment adds this on its own, behind the scenes: */
int main(void)
{
    init();          // configures the timers and the ADC, called automatically

    setup();         // once, at power-up

    for (;;) {       // infinite loop
        loop();      // forever
    }
    return 0;        // never reached
}

6Execution simulator

Follow, step by step, the real order of execution: setup() runs once, then loop() repeats forever. Watch the value of the static counter, which proves that the function really is being called repeatedly.

7Data types on AVR

Important qualifiers

8Wiring diagram

9Source code

The minimal program - Blink

const uint8_t LED_PIN = 8;    // const + uint8_t: does not waste RAM

void setup() {
  pinMode(LED_PIN, OUTPUT);   // the pin becomes an output
}

void loop() {
  digitalWrite(LED_PIN, HIGH);  // turn on
  delay(500);                   // wait 500 ms
  digitalWrite(LED_PIN, LOW);   // turn off
  delay(500);
}

The same behavior, at the register level

The functions pinMode() and digitalWrite() exist only in the Arduino environment. The same operations written directly on the registers work on any AVR compiler and run about 50 times faster:

void setup() {
  DDRB |= (1 << PB0);           // pin 8 becomes an output  (same as pinMode(8, OUTPUT))
}

void loop() {
  PORTB |=  (1 << PB0);         // pin 8 to HIGH             (same as digitalWrite(8, HIGH))
  delay(500);
  PORTB &= ~(1 << PB0);         // pin 8 to LOW              (same as digitalWrite(8, LOW))
  delay(500);
}

Debugging without a screen: the LED as a tool

The microcontroller has no screen. Until the sixth lab, when you learn serial communication and can send text to the computer, the only debugging tool you have is the LED itself: you use it to show that the program has reached a certain point, or to "display" a small number, through counted blinks.

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  static uint8_t counter = 0;    // static: keeps its value between calls
  counter++;

  // "display" the counter: one blink for each unit
  for (uint8_t i = 0; i < counter; i++) {
    digitalWrite(13, HIGH);
    delay(150);
    digitalWrite(13, LOW);
    delay(250);
  }

  delay(1500);                   // long pause = the "display" has finished
  if (counter >= 5) counter = 0;  // start over
}

Checking available memory

The sizes of the types are in the table in chapter 7. How much RAM is still free, however, can only be found out at run time, with the function below. Having no serial monitor yet, the program does not print the value, but signals it: if free memory drops below a threshold, the LED stays lit continuously.

// Returns the number of free bytes between the heap and the stack
int freeMemory() {
  extern int __heap_start, *__brkval;
  int v;
  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
}

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  if (freeMemory() < 256) {
    digitalWrite(13, HIGH);       // alarm: memory nearly exhausted
  } else {
    digitalWrite(13, LOW);
  }
  delay(500);
}

10Interactive circuit

The circuits below run the code right on the page, on a simulated ATmega328P. It is not an animation: PORTB really does drive the pin, the LED lights up because bit 5 became 1, and the 16 MHz clock runs just like on the real board. Press Start, then change the code and start again.

void setup() {
  pinMode(13, OUTPUT);      // pin 13 becomes an output
}

void loop() {
  digitalWrite(13, HIGH);   // turn on
  delay(500);               // wait 500 ms
  digitalWrite(13, LOW);    // turn off
  delay(500);
}

/* Dot = 200 ms on, dash = 600 ms on.
   Between signals: 200 ms pause. Between letters: 600 ms pause. */

void dot() {
  digitalWrite(13, HIGH);
  delay(200);
  digitalWrite(13, LOW);
  delay(200);
}

void dash() {
  /* Complete this: same as dot(), but on for 600 ms */
}

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  dot(); dot(); dot();     // S
  delay(400);
  /* Complete this: three dashes for O, then three dots for S,
     then a long 2000 ms pause before repeating. */
}

11Work tasks

• Install the Arduino IDE, select the Arduino Uno board and the correct serial port.
• Upload the Blink program and check that the onboard LED (D13) works.
• Wire up an external LED with a 220 Ω resistor on pin D8 and modify the program.
• Calculate the current through the LED and check that it stays under 20 mA.
• Change the timing so the LED is on for 100 ms and off for 900 ms.
• Run the size-checking program and note the values for int and long.
• Experimentally verify the int t = 1000 * 60; trap and fix it with the L suffix.
• Display the free RAM and watch how it drops after declaring an array of 200 int.

12Extended application

13Review questions

14Resources

• This lab's handout (PDF)
• The complete lab handout
• The course page - all materials