First, let's grab a potentiometer. A potentiometer is, if you remember correctly from the first chapter of this book, a variable resistor.

Considering Ohm's law, which links voltage, current, and resistance value, we can understand that, for a constant current, we can make the voltage vary by changing the value of the resistance of the potentiometer. Indeed, because some of us haven't dusted off our elementary electronics course textbook in many years, how about a refresher? Here's Ohm's law:

V = R * I

Here, V is the voltage in Volts, R the resistance in Ohms, and I the current in Amperes.

So now, to define the purpose of a potentiometer:

The following figure is the most basic circuit to illustrate the concept of analog inputs with the Arduino board:

A potentiometer connected to the Arduino board

Check the corresponding electrical diagram for connections:

Analog input 0 is measuring the voltage

Now let's see the code we have to use.

Like the function digitalRead(), which can read the value of digital inputs on the Arduino, there is analogRead() for doing the same with analog inputs.

The intention here is to read the value as a pause value in our program for the purpose of controlling the blink rate of an LED. In code, we'll be using the delay() function.

Here's an example:

int potPin = 0;     // pin number where the potentiometer is connected
int ledPin = 13 ;   // pin number of the on-board LED
int potValue = 0 ;  // variable storing the voltage value measured at potPin pin

void setup() {
  pinMode(ledPin, OUTPUT);  // define ledPin pin as an output
}

void loop(){
  potValue = analogRead(potPin); // read and store the read value at potPin pin 
  
  digitalWrite(ledPin, HIGH);    // turn on the LED
  delay(potValue);               // pause the program during potValue millisecond
  digitalWrite(ledPin, LOW);     // turn off the LED
  delay(potValue);               // pause the program during potValue millisecond
}

Upload the code. Then turn the pot a bit, and observe the output.

After the variable definition, I'm defining the ledPin pin as output in the setup() function in order to be able to drive current to this pin. Actually, I'm using pin 13 in order to simplify our tests. Don't forget pin 13 is the surface-mounted LED on the Arduino board.

Then, the magic happens in the loop() function.

I'm first reading the value at the potPin pin. As we discussed before, the value returned by this function is an integer between 0 and 1023. I'm storing it in the potValue variable to keep the LED ON, but also to keep it OFF.

Then, I'm turning OFF and ON the LED with some delay between status changes. The smart thing here is to use potValue as the delay. Turned on one side completely, the potentiometer provides a value of 0. Turned on the other side completely, it provides 1023, which is a reasonable and user-friendly delay value in milliseconds.

The higher the value is, the longer the delay.

In order to be sure you understood the physical part of this, I'd like to explain a bit more about voltage.

The +5 V and ground pins of the Arduino supply the potentiometer the voltage. Its third leg provides a way to vary the voltage by varying the resistance. The Arduino's analog inputs are able to read this voltage. Please notice that analog pins on the Arduino are inputs only. This is also why, with analog pins, we don't have to worry about precision in the code like we have for digital pins.

So let's modify the code a bit in order to read a voltage value.

Measuring voltage requires two different points on a circuit. Indeed, a voltage is an electrical potential. Here, we have (only) that analog pin involved in our circuit to measure voltage. What's that ?!

Simple! We're using the +5 V supply from Vcc as a reference. We control the resistance provided by the potentiometer and supply the voltage from the Vcc pin to have something to demonstrate.

If we want to use it as a real potentiometer, we have to supply another part of a circuit with Vcc too, and then connect our A0 pin to another point of the circuit.

As we saw, the analogRead() function only provides integers from 0 to 1023. How can we have real electrical measures displayed somewhere?

Here's how it works:

The range 0 to 1023 is mapped to 0 to 5V. That comes built into the Arduino. We can then calculate the voltage as follows:

V = 5 * (analogRead() value / 1023)

Let's implement it and display it on our computer by using the serial monitor of the Arduino IDE:

int potPin = 0;     // pin number where the potentiometer is connected
int ledPin = 13 ;   // pin number of the on-board LED
int potValue = 0 ;  // variable storing the voltage value measured at potPin pin
float voltageValue = 0.; // variable storing the voltage calculated

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);  // define ledPin pin as an output
}

void loop(){
  potValue = analogRead(potPin); // read and store the read value at potPin pin

  digitalWrite(ledPin, HIGH);    // turn on the LED
  delay(potValue);               // pause the program during potValue millisecond
  digitalWrite(ledPin, LOW);     // turn off the LED
  delay(potValue);               // pause the program during potValue millisecond

  voltageValue = 5. * (potValue / 1023.) ;  // calculate the voltage

  Serial.println(voltageValue); // write the voltage value an a carriage return
}

The code is almost the same as the previous code.

I added a variable to store the calculated voltage. I also added the serial communication stuff, which you see all the time: Serial.begin(9600) to instantiate the serial communication and Serial.println() to write the current calculated voltage value to the serial communication port, followed by a carriage return.

In order to see a result on your computer, you have to turn on the serial monitor, of course. Then, you can read the voltage values.