The Blink Sketch

To blink an LED, you have to run a “sketch” on the Arduino. An Arduino sketch hides a lot of the complexity from a microcontroller. The Arduino IDE comes with a number of sketch examples to learn embedded development. Writing, building, and uploading a Blink sketch will give you a first feeling of how microcontrollers work.

If you create a new Arduino sketch, you’ll see the following basic code structure:

void setup() {
}

void loop() {
}

These two functions are the foundation of every Arduino program. The setup() function is where you put code to configure the hardware and initialize variables. This function will only run once when your Arduino is turned on. The loop() function is where the the “main” program goes. We’ll see shortly how this looks for a blinking LED. Note that most Arduino boards have an LED connected to pin 13, which you can easily toggle for testing.

The separation of code into setup() and main loop() is common in the embedded world. First, you’ll have a function to configure your microcontroller and peripherals. Then follows an infinite loop, where different instructions are executed. The code in the infinite loop is repeated as long as the device has power. To make an LED blink with an Arduino forever, you would use the following:

void setup() {
    // initialize the digital pin as an output.
    pinMode(13, OUTPUT);
    }

void loop() {
    digitalWrite(13, HIGH);  // turn LED on
    delay(1000);             // wait for a second
    digitalWrite(13, LOW);   // toggle LED
    delay(400);              // wait 400 ms
    }

While keywords such as void are part of C, Arduino programs contain more keyword-like commands such as pinMode, delay, and digitalWrite as just shown. These commands are part of a hardware abstraction layer (or HAL) Arduino provides to hide the lower-level complexities of a microcontroller. No matter which Arduino board you use, these statements are properly translated to pin configurations. By the way, pinMode configures the mode of a pin (i.e., if it is an input or output). If a pin is configured as output, you can write state with digitalWrite. If the pin is an input, you can read state with digitalRead.

Note the name of the instructions to change the state of pins. The Arduino nomenclature has made its way into some JavaScript libraries, as you will see shortly. Before examining how, let’s see the Arduino example in action.

A look at the Arduino IDE (shown in Figure 2-4) quickly reveals two functions: a “verify” button that compiles C and C++ to byte sequences that a microcontroller can run and an “upload” button that places your code in the free program memory of a microcontroller (ROM).

Figure 2-4. The Arduino IDE

If you have an Arduino and press the compile button, in the console you will see:

Sketch uses 1,030 bytes (3%) of program storage space. Maximum is 30,720 bytes.
Global variables use 9 bytes (0%) of dynamic memory, leaving 2,039 bytes for
  local variables. Maximum is 2,048 bytes.

This shows how compact the code is. The code will use only 1 KB of flash memory. And, only 9 bytes of RAM are necessary!

Next, you can press the upload button. After a brief wait while the device is flashed, you will see LED 13 blinking, as shown in Figure 2-5.

Figure 2-5. The default LED to blink on the Arduino Uno

Similarly, you could explore using input pins or different forms of output signals. We’ll discuss more features of microcontrollers later. Let’s first look at controlling an Arduino with JavaScript.

Programming an Arduino with JavaScript

Once you have checked your connection to an Arduino with a Firmata test client, you can bind a JavaScript process to your board.

To talk with Firmata from JavaScript, you can use the Firmata library, originally written by Julian Gautier and currently maintained by Rick Waldron.

In a new project, you can start with:

$ npm init --y
$ npm install --save firmata

With this library, we can connect to input and output pins.

Let’s look at a blinking LED again:

// blink_led.js
// the Firmata protocol provides a simple protocol to an embedded system
var Board = require('firmata');

Board.requestPort(function(error, port) {
  if (error) {
    console.log(error);
    return;
  }
  var board = new Board(port.comName);

  // start to blink when the Arduino is ready
  board.on("ready", function() {

    // main part
    console.log('connected:  ' +  modem);
    var ledOn = true;

    // configure pin 13 as output
    board.pinMode(13, board.MODES.OUTPUT);
    // blink the LED
    setInterval(function() {
      if (ledOn) {
        console.log('ON');
        board.digitalWrite(13, board.HIGH);
      } else {
        console.log('OFF');
        board.digitalWrite(13, board.LOW);
      }
      ledOn = !ledOn;
    }, 500);
  });

To blink the LED, run the preceding script with Node.js:

$ node blink_led

If everything worked, you should see the LED turning on and off. This is also a good moment to compare the differences in code expressed in terms of Arduino and JavaScript.

In the JavaScript example, you get a board object, where you can listen to events from the hardware. For the blink example, you first wait until the board emits the “ready” event (the connection works properly). Once this happens, you can change the state of the board with functions using digitalWrite and pinMode. You could easily interact with the JavaScript board object in a web server or web interface too (we’ll discuss how to do this in Chapters 9 and 10).

Pins

Pins of an MCU come in two categories: inputs and outputs. A pin can either “drive” signals to peripherals and components, or it can “detect” changes from the outside.

Inputs and outputs are technically quite different. While inputs are all about capturing the state of signals, outputs can drive current into components. Because Arduino boards are capable of driving several milliamperes of current, they’re a good fit for controlling small actuators such as motors or lights.

Besides acting as “force” (output pin) or “sink” (input pin), pins carry analog or digital signal types (see the following sidebar for details on how this works).

When writing embedded software, the first step is to locate and configure the pins of the microcontroller. For example, an Arduino Uno has 5 analog inputs and 13 digital pins known as general-purpose input/outputs (GPIOs). Of these 13 GPIOs, 5 pins can emulate an analog output with the help of pulse-width modulation (PWM), as will be discussed in “Pulse-Width Modulation”.

On an Arduino, you first configure the direction of a pin. To read data from it with software, you must configure the pin as input. With Arduino and Firmata, if you want GPIO pin 12 to be an input, you would configure it as follows:

board.pinMode(12, board.MODES.INPUT);

Or, to write data to another device, you can configure another pin as output:

board.pinMode(12, board.MODES.OUTPUT);

On an Arduino, toggling a digital pin to a high voltage is done with:

board.digitalWrite(13, board.HIGH);

To write a low voltage, you would write:

board.digitalWrite(13, board.LOW);

Besides simple inputs and outputs, port pins often provide more functions. This means you not only can read a digital state, or write it, you can also start up special forms of communication, such as PWM and hardware communication protocols.

When different resources on a chip use the same port pins, we are referring to “multiplexing” pin functions. The way this works is defined by the chip architecture of a microcontroller defines how multiplexing works. Let’s dig into the building blocks of a microcontroller starting with its CPU.

Microcontroller Versus Microprocessor

On top of providing pins for building circuits, microcontrollers can run programs with the help of a CPU. The datasheets for a microcontroller provide all the details, and the following specs are of particular interest:

• The amount of memory (volatile and nonvolatile) to store variables and code

• The type of instruction set to execute code and operations with variables

• The timers to change pin states with high timing accuracy

• The power consumption at a certain operating frequency

Compared to the CPU of a bigger computer, these parameters make a microcontroller nice for embedded systems on a battery. Moreover, the costs of microcontrollers can be significantly lower than those of microprocessors (though microprocessors are becoming cheaper due to high volume demands).

However, microcontrollers also have disadvantages. In particular, their performance for computations can be a problem. If you want to connect a microcontroller to a network, or if you want to run a web server or database, this is where microprocessors become very interesting.

Microprocessors (MPUs) have many more pins, more memory, and much more power for computations. The boundaries between MCU and MPU are not always clear, but you will usually have to deal with some tradeoffs when chosing a board with a microcontroller or microprocessor.

In earlier code examples, we worked with a number of functional blocks of a microcontroller. As you can see from the block diagram, Arduino provides several hardware abstractions.

Let’s look a bit deeper into the structures and functions of the main building blocks of an Arduino Uno: the Atmel ATmega328 microcontroller.

Block Diagrams

To understand how the software in the microcontroller blinks the LED, let’s look at the block diagram of the ATmega328 microcontroller, shown in Figure 2-8. In general, understanding functional block diagrams is important when developing software for embedded devices.

The block diagram in Figure 2-8 shows the typical building blocks of a microcontroller. The CPU of the ATmega328 has an 8-bit instruction set. Instruction sets provide operations around which programmers build programming languages and compilers.

The code and data are stored in different forms of memory. In Figure 2-8, the memory is shown in the upper-right part. “Flash” generally means slow, nonvolatile memory, and SRAM means fast but volatile memory. You generally store programs in flash, while the RAM at runtime of a program is stored in SRAM.

Besides these building blocks, what is interesting from a software perspective are the interfaces of the microcontroller. These are all the arrows that come out and go in on the bottom and left—for example, the ports.

Figure 2-8. A functional block diagram of the datasheet from the ATmega 328 microcontroller

With GPIOs, it is possible to read and write data. From the block diagram, you can see that an Atmel MCU has GPIOs that are organized in three ports: Port B, Port C, and Port D (seen near the bottom of Figure 2-8).

So-called “peripherals” are also important for communication and sensing the outside world. Some peripherals act as input and output ports. Timers can measure the time between stop and start events. And, analog-to-digital converters can convert continuous analog signals into bits and bytes for digital processing.

The ATmega328 Atmel chip multiplexes the following blocks to the ports:

Port D provides USART and UART

Many embedded devices must transfer data from one side to another. One kind of serial data transfer uses a Universal Synchronous Asynchronous Receiver/Transmitter (USART). This peripheral function drives data bits from a sender to a receiver via two wires and an extra clock line. One variation on USART is called UART (Universal Asynchronous Receiver/Transmitter). In this form, a clock can be generated on the devices, and there is no need for an extra clock line. We’ll discuss serial communication in several places throughout the book.

Port B provides SPI communication

Serial peripheral interface (SPI) is another approach to communicating between devices. SPI connects devices in a “master” and “slave” fashion.² This means one device controls the communication flow. This kind of communication is a relatively fast form of serial communication. The SPI protocol requires four signals for communication. Since it always uses a clock line, the communication happens synchronous.

Port C provides TWI

The ATmega328 includes another form of serial communication called a two-wire interface (TWI). It is more commonly known as I2C (“i squared c”) and is popular for slow communication with sensors or displays. I2C uses one line for a clock signal, which means that I2C communication also happens synchronous.

Most communication modes are directly supported by JavaScript libraries. Serial communication is very common for many use cases. A JavaScript library for serial communication will be discussed in Chapter 8. Let’s continue with pins that are important to sense the physical world around us.

Analog Inputs

Looking at the building blocks in Figure 2-8, we can see a rectangle “A/D conversion.” Not all pins on the Arduino support reading analog values, only pins A0 to A5. The analog input block provides a number of “channels” to measure the physical environment with sensors.

In the Arduino language, these pins read a variable (“analog”) voltage and report that value as a 10-bit number representing 0–5V. An analog value has a “continuous” value in a range, so it does not represent a state. The range is represented by a resolution with bits—for example, a 10-bit A/D converter has 2¹⁰ different values, or 1024 values (in hex values the range would be 0x00–0x3ff).

The simplest approach to understanding what happens when reading an analog input is with a potentiometer.

If you connect a potentiometer to analog input A0 as shown in Figure 2-9, you can read the analog voltage on the input pin with:

board.analogRead(0, function(data) {
  console.log(data);
});

Figure 2-9. Potentiometer connected to analog input A0

You could influence the delay of the blinking LED on an Arduino as follows:

// analog_read.js
// load firmata dependency
var Board = require('firmata');

// pin definitions
const LED = 5;
const POT = 0;

// init variables
var ledOn = 0;  // whether LED is ON or OFF
var delay = 0;  // blink delay

// make connection
Board.requestPort(function(error, port) {

  if (error) {
     console.log(error);
     return;
  }

  var board = new Board(port.comName);

  // wait for connection
  board.on("ready", function() {

    function blink() {
      board.digitalWrite(LED, ledOn);
      ledOn = !ledOn;
      setTimeout(blink, delay);
    }

    // update variable
    board.analogRead(0, function(d) {
      delay = d;
    });

    blink();
  });
});

Often, you need to scale the input range of a sensor, or as in this example, the potentiometer (POT). In this case, the value from the analog pins returns a value between 0 an 1023. This values affects the delay for blinking.

When the blink delay is below 100 ms, the human eye cannot perceive the blink of the LED anymore. To map the blink delay to a range that can be seen by the human eye, you use a “map” function. The function from Arduino map can be rewritten in JavaScript as follows:

function map(x, in_min, in_max, out_min, out_max)
{
    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
// e.g. map(value, 0, 1023, 400, 1600) --> maps a value in a range from 400 to 1600

Now, the full variable blink example reads:

// map_example.js
var Board = require('firmata');

// pin definitions
const LED = 5;
const POT = 0;

// init variables
var ledOn = 0;  // whether LED is ON or OFF
var delay = 0;  // blink delay

function map(x, in_min, in_max, out_min, out_max)
{
    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

// make connection
Board.requestPort(function(error, port) {

  if (error) {
     console.log(error);
     return;
  }

  var board = new Board(port.comName);

  // wait for connection
  board.on("ready", function() {

  function blink() {
    board.digitalWrite(LED, ledOn);
    ledOn = !ledOn;
    setTimeout(blink, delay);
  }

  // update variable
  board.analogRead(0, function(d) {
    delay = map(d, 0, 1023, 400, 1600);
  });

      blink();
    });
  });

If you turn the knob of the potentiometer to the left, you get a minimum blink delay of 400 ms. If you turn the knob to the right, the delay will be 1.6 s.

Pulse-Width Modulation

In many projects, you not only have the requirement to sense the environment, you will also need to change the environment. This is what actuators are about. An actuator can be a motor, a loudspeaker, or again, the blink of an LED.

Actuators respond to signals with different forms. Pulses with different widths are especially common. This modulation scheme is called pulse-width modulation (PWM). As you can see in Figure 2-10, you specify the percentage of the time that the signal is high, also known as the “duty cycle.” This results in an often uneven square wave, as the pin approximates a percentage of the full signal by quickly toggling how long the signal is on versus off within a short period.

Figure 2-10. Pulse-width modulation; play with it here http://embeddednodejs.com/pwm

To generate PWM signals, a microcontroller often can often reuse exisiting blocks, such as GPIO and internal timers on the chips.

The mechanism behind PWM is as follows: an internal timer on the MCU sets the state of a pin to HIGH for a certain time, and LOW for the rest of a cycle. On average, the output is an analog voltage between ground and the supply voltage. This approximates an analog value and works fine for slow actuators. If you want fast-changing analog signals, such as needed for good quality audio, you’ll need to explore the use of digital-to-analog converters (DACs). Unfortunately, simple Arduinos don’t have DACs onboard.

Let’s now get some practice using PWM to fade an LED. The Arduino example “fade” can be translated to JavaScript as follows:

// analog_write.js
var Board = require('firmata');

// led pin
const LED = 5;

var brightness = 0;
var fadeAmount = 5;
Board.requestPort(function(error, port) {

if (error) {
   console.log(error);
   return;
}

var board = new Board(port.comName);
board.on("ready", function() {

// configure pin as PWM
board.pinMode(LED, board.MODES.PWM);

// fade the LED every 30 ms
function fadeLed() {
  brightness += fadeAmount;

      if (brightness == 0 || brightness == 255) {
        fadeAmount = -fadeAmount;
      }
      board.analogWrite(LED, brightness);
      setTimeout(fadeLed, 30);
    }
    fadeLed();
  });
});

A small warning: not every digital pin has access to a timer/counter. So, not every pin is able to drive a PWM output. On an Arduino, there are usually six pins with PWM functionality. These pins are commonly marked with a tilde.

Pinouts

Because reading functions of pins in datasheets is a time-intensive process, so-called pinout diagrams—like the one shown in Figure 2-11—help visualize pin functions.

While datasheets provide many details of what is going inside a chip, software developers are mostly interested in the interfaces of chips. To make writing embedded software easier, pinouts are a handy way to look up the names or locations of pins.

Figure 2-11. An Arduino Uno pinout that shows the location and functions of pins (http://www.pighixxx.com/test/pinouts/boards/uno.pdf)

From this pinout, we quickly get an overview of the different pin functions. In addition to the pin mapping that Arduino libraries use, you’ll see the name of the lower-level name and function from the datasheet. For example:

Arduino Pin 9 | Physical Pin 15 | Port B | Output/Compare/Timer 1

For beginners of embedded development, consulting a pinout can be simpler than reading dense datasheets. Later, when you get more familiar with a microcontroller, you can explore the alternative functions of pins in a pinout or datasheet.

PighiXXX provides pinout diagrams for a number of popular Arduino boards.