Reading Analog Sensors with analogRead()

1. Analog vs. Digital Signals

Let's start with a quick recap. A digital signal is discrete, like a light switch—it's either fully ON (HIGH) or fully OFF (LOW). This is what we worked with in the last two lessons.

An analog signal, on the other hand, is continuous. It can have any value within a given range. Think of a classic volume knob on a stereo or a dimmer switch for a light. You can turn it to any position, not just on or off.

A potentiometer is a perfect component to demonstrate this. It's a variable resistor that, when wired correctly, acts as a voltage divider to produce a continuously variable voltage.

As you saw, by turning the knob, you change the ratio of resistance, which in turn changes the voltage on the middle pin from 0V all the way up to 5V. But how does the Arduino, a digital device, make sense of this analog voltage?

2. The Analog-to-Digital Converter (ADC)

The Arduino's microcontroller can't work with analog voltages directly. It needs to convert them into a digital number it can understand. This crucial job is performed by a built-in piece of hardware called the Analog-to-Digital Converter (ADC).

The ADC in the Arduino UNO has two key characteristics:

1. Reference Voltage (VREF): By default, this is the board's operating voltage, which is 5V. This is the maximum voltage the ADC can measure.
2. Resolution: The ADC has a 10-bit resolution. This means it can represent the analog voltage using $2^{10}=1024$ discrete steps.

These steps are numbered from 0 to 1023. So, the ADC maps the analog voltage range of 0V to 5V onto the digital number range of 0 to 1023.

• An input of 0V will be converted to the number 0.
• An input of 5V will be converted to the number 1023.
• An input of 2.5V (halfway) will be converted to approximately 512.

This conversion allows your C++ code to work with a simple integer value that represents the real-world voltage.

3. Building the Circuit and Reading the Value

Let's build the circuit and write the code to read a value from the potentiometer.

Wiring

You'll need your Arduino, a breadboard, a potentiometer, and some jumper wires.

It doesn't matter which outer pin goes to 5V and which to GND; swapping them will simply reverse the direction of the knob's readings (e.g., clockwise increasing vs. counter-clockwise increasing).

The analogRead() Function

Reading the value is surprisingly simple. We use the analogRead(pin) function. It takes one argument—the analog pin you want to read (e.g., A0)—and returns an integer (int) between 0 and 1023.

Let's write a sketch to read the value from pin A0 and display it using the Serial Monitor.

// Define the analog pin we connected the potentiometer to
const int potPin = A0;

void setup() {
  // Initialize the serial monitor to display the readings
  Serial.begin(9600);
}

void loop() {
  // Read the raw value from the potentiometer (0-1023)
  int sensorValue = analogRead(potPin);

  // Print the value to the Serial Monitor
  Serial.print("Raw ADC Value: ");
  Serial.println(sensorValue);

  // Wait a little bit before the next reading
  delay(100);
}

Upload this code, open your Serial Monitor (Tools > Serial Monitor), and turn the potentiometer knob. You should see the numbers change smoothly between 0 and 1023.

4. Converting Raw Values to Voltage

The raw 0-1023 value is useful, but often we want to know the actual voltage being measured. To do this, we need to perform a simple calculation. Since 1023 represents 5V, we can convert our ADC value back to voltage with this formula:

Notice the .0 in 5.0 and 1023.0. This is very important in C/C++. It tells the compiler to perform floating-point arithmetic. If you wrote (5 / 1023), the compiler would perform integer division, which would result in 0, and your voltage calculation would always be zero! Since you're proficient in other languages, you'll recognize this as a key low-level detail to be mindful of in C/C++.

Let's update our code to display the voltage.

const int potPin = A0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  // Read the raw value from the potentiometer (0-1023)
  int sensorValue = analogRead(potPin);

  // Convert the ADC value to a voltage (0V - 5V)
  // Use a float variable to store the result
  float voltage = sensorValue * (5.0 / 1023.0);

  // Print both values
  Serial.print("Raw ADC Value: ");
  Serial.print(sensorValue);
  Serial.print("\t | Voltage: "); // Use a tab character for nice formatting
  Serial.print(voltage);
  Serial.println(" V");

  delay(100);
}

Upload this new sketch. Now your Serial Monitor will show both the raw ADC value and the corresponding voltage, giving you a much more intuitive understanding of the signal.

Conclusion

Congratulations! You've successfully bridged the gap between the analog physical world and the digital domain of the microcontroller. You can now read continuous sensor data, a skill that opens the door to countless projects, from building weather stations to creating musical instruments or controlling robotic arms.

Key Takeaways:

• Analog signals are continuous, unlike binary digital signals.
• A potentiometer acts as a variable voltage divider to produce an analog voltage.
• The Analog-to-Digital Converter (ADC) is the hardware that converts an analog voltage into a digital number.
• The Arduino UNO has a 10-bit ADC, which means it maps the 0-5V input range to a digital value from 0 to 1023.
• The analogRead(pin) function performs this conversion and returns the integer value.
• You can convert the raw ADC value back to voltage using the formula voltage = value * (5.0 / 1023.0), being careful to use floating-point math.

Next Up

Reading an analog value is only half the story. The next logical step is to use that value to control something. In our next lesson, we will learn about Pulse Width Modulation (PWM), a technique that allows an Arduino to produce a pseudo-analog output. We'll combine today's lesson with the next one to use the potentiometer to control the brightness of an LED.