A_2: Arduino-based Digital Stopwatch with Lap Timing and Data

Storage

Experiment 1: Interfacing an I2C LCD with Arduino

Introduction

In this lab, you will learn how to interface an I2C (I²C or Inter-Integrated Circuit) LCD display
with an Arduino microcontroller. LCD displays are widely used for visualizing data and messages
in various electronic projects. Interfacing an I2C LCD with Arduino simplifies the connection and
reduces the number of pins required, making it an efficient choice for your projects.

Objectives

 Understand the basics of LCD displays and their importance in microcontroller projects.

 Learn how to interface an I2C LCD display with an Arduino.

 Write and upload Arduino code to display text and custom characters on the LCD screen.

Materials

 Arduino Uno or similar board.

 I2C LCD module (e.g., 16x2 or 20x4 LCD with I2C backpack).

 Jumper wires.

 Breadboard (optional).

Procedure

Step 1: Setting Up the Hardware

1. Connect the I2C LCD module to the Arduino:

 Connect the VCC (power) and GND (ground) pins on the LCD module to the 5V
and GND pins on the Arduino, respectively.

 Connect the SDA (data) and SCL (clock) pins on the LCD module to the
corresponding pins on the Arduino. On most Arduino boards, SDA is A4, and SCL
is A5.

2. Verify your connections carefully to ensure they are correct.

1. Open the Arduino IDE

2. Install the LiquidCrystal I2C library

To easily control the I2C LCD, you will need to install the “LiquidCrystal I2C” library.

 Open the Arduino IDE.

 Go to “Sketch” -> “Include Library” -> “Manage Libraries...”

 In the Library Manager, type “LiquidCrystal I2C” in the search bar.

 Click "Install" to install the library.

Step 3: Writing the Arduino Code

1. Open a new Arduino sketch

 Open the Arduino IDE.

 Click "File" -> "New" to create a new sketch.

2. Write the code to initialize and display text on the LCD

#include <Wire.h> // Include the Wire library for I2C communication

#include <LiquidCrystal_I2C.h> // Include the LiquidCrystal I2C library

LiquidCrystal_I2C lcd(0x27, 16, 2); // Set the LCD address (0x27 for a 16x2 display)

void setup() {

lcd.init(); // Initialize the LCD

lcd.backlight(); // Turn on the backlight (if available)

lcd.setCursor(0, 0); // Set cursor to the first row, first column

lcd.print("Hello, World!");

void loop() {

// Your code goes here

}
  Make sure to modify the LiquidCrystal_I2C constructor with the correct address
(0x27 is common, but it may vary depending on your module).

2. Upload the code to the Arduino

 Connect your Arduino to your computer using a USB cable.

 Select the correct Arduino board and port in the "Tools" menu.

 Click the "Upload" button (arrow icon) to upload the code to the Arduino.

Step 4: Testing

1. After uploading the code, you should see the text “Hello, World!” displayed on your
LCD.

2. Experiment with the LCD functions and display your own messages and data.

Conclusion

In this lab, you successfully interfaced an I2C LCD display with an Arduino and displayed text
on the screen. You also learned how to install libraries and write Arduino code for controlling the
LCD. LCD displays are versatile and can be used to enhance various Arduino projects by
visualizing information effectively.

Experiment 2: Designing an Automatic Stopwatch with Arduino and I2C LCD

Introduction

In this lab, you will learn how to design and build an automatic stopwatch using an Arduino
microcontroller and an I2C (I²C or Inter-Integrated Circuit) LCD display. A stopwatch is a valuable
tool in various applications, from sports timing to industrial processes. In this project, you will
create a digital stopwatch that starts, stops, and resets automatically.

Learning Objectives

 Understand the principles of digital timing and event tracking.

 Interface an I2C LCD display with an Arduino.

 Write Arduino code to implement a digital stopwatch with start, stop, and reset functions.

Materials
  Arduino Uno or similar board.

 I2C LCD module (e.g., 16x2 or 20x4 LCD with I2C backpack).

 Push-button switches (at least two).

 10kΩ resistors (2).

 Jumper wires.

 Breadboard (optional).

Procedure

Step 1: Setting Up the Hardware

1. Connect the I2C LCD module to the Arduino:

 Connect the VCC (power) and GND (ground) pins on the LCD module to the 5V
and GND pins on the Arduino, respectively.

 Connect the SDA (data) and SCL (clock) pins on the LCD module to the
corresponding pins on the Arduino. On most Arduino boards, SDA is A4, and SCL

is A5.

2. Connect the push-button switches:

 Connect one terminal of each push-button to a digital pin on the Arduino (e.g., Pin
2 for Start/Stop and Pin 3 for Reset).

 Connect the other terminal of each push-button to the ground (GND) through a
10kΩ resistor.

Step 3: Writing the Arduino Code

1. Open a new Arduino sketch:

 Open the Arduino IDE.

 Click “File” -> “New” to create a new sketch.

2. Write the code for the automatic stopwatch:

#include <Wire.h> // Include the Wire library for I2C communication

LiquidCrystal_I2C lcd(0x27, 16, 2); // Set the LCD address (0x27 for a 16x2 display)

const int startStopButtonPin = 2; // Pin for the Start/Stop button

const int resetButtonPin = 3; // Pin for the Reset button

unsigned long startTime = 0; // Variable to store the start time

unsigned long elapsedTime = 0; // Variable to store the elapsed time

boolean timing = false; // Flag to indicate if timing is active

void setup() {

lcd.init(); // Initialize the LCD

lcd.backlight(); // Turn on the backlight (if available)

lcd.setCursor(0, 0); // Set cursor to the first row, first column

lcd.print(“Press Start”);

pinMode(startStopButtonPin, INPUT_PULLUP); // Set the Start/Stop button pin as input

pinMode(resetButtonPin, INPUT_PULLUP); // Set the Reset button pin as input

void loop() {

// Check if the Start/Stop button is pressed

if (digitalRead(startStopButtonPin) == LOW) {

if (!timing) {

startTime = millis(); // Start timing

timing = true;

lcd.clear();

lcd.setCursor(0, 0);
 lcd.print("Timing...");

} else {

elapsedTime += millis() - startTime; // Stop timing

timing = false;

lcd.clear();

lcd.setCursor(0, 0);

lcd.print("Press Start");

delay(100); // Debounce

// Check if the Reset button is pressed

if (digitalRead(resetButtonPin) == LOW) {

elapsedTime = 0; // Reset the elapsed time

timing = false;

lcd.clear();

lcd.setCursor(0, 0);

lcd.print("Press Start");

delay(100); // Debounce

// Display the elapsed time on the LCD

lcd.setCursor(0, 1);

lcd.print(“Time: “);

lcd.print(elapsedTime / 1000); // Convert milliseconds to seconds

lcd.print(“s”);

}
 1. Upload the code to the Arduino:

 Connect your Arduino to your computer using a USB cable.

 Select the correct Arduino board and port in the "Tools" menu.

 Click the "Upload" button (arrow icon) to upload the code to the Arduino.

Step 4: Testing

1. After uploading the code, press the Start/Stop button to start and stop the stopwatch.

2. Press the Reset button to reset the stopwatch to zero.

3. Observe the elapsed time displayed on the LCD screen.

4. Experiment with the stopwatch and explore how it behaves when you start, stop, and
reset it.

Conclusion

In this lab, you successfully designed an automatic stopwatch using an Arduino and an I2C LCD
display. You learned how to interface push-button switches, control timing, and display
information on the LCD. Digital stopwatches are useful in various applications, including timing
experiments, races, and other time-sensitive tasks.

Experiment 3: Designing an Automatic Stopwatch with Lap Timing and Data Storage

Introduction

In this lab, you will learn how to design and build an automatic stopwatch using an Arduino
microcontroller and an I2C (I²C or Inter-Integrated Circuit) LCD display. This stopwatch will have
additional features such as lap timing and the ability to store recorded lap times even after the
Arduino is reset or powered off. Lap timing is useful for tracking multiple time intervals, and data
storage ensures that recorded times are not lost.

Learning Objectives

 Understand the principles of digital timing, lap timing, and data storage.

 Interface an I2C LCD display with an Arduino.

 Write Arduino code to implement a digital stopwatch with start, stop, reset, lap timing, and
data storage functions.
 Materials

 Arduino Uno or similar board.

 I2C LCD module (e.g., 16x2 or 20x4 LCD with I2C backpack).

 Push-button switches (at least three).

 10kΩ resistors (3).

 Jumper wires.

 Breadboard (optional).

Procedure

Step 1: Setting Up the Hardware

1. Connect the I2C LCD module to the Arduino:

 Connect the VCC (power) and GND (ground) pins on the LCD module to the 5V
and GND pins on the Arduino, respectively.

 Connect the SDA (data) and SCL (clock) pins on the LCD module to the
corresponding pins on the Arduino. On most Arduino boards, SDA is A4, and SCL
is A5.

2. Connect the push-button switches:

 Connect one terminal of each push-button to a digital pin on the Arduino (e.g., Pin
2 for Start/Stop, Pin 3 for Reset, and Pin 4 for Lap).

 Connect the other terminal of each push-button to the ground (GND) through a
10kΩ resistor.

Step 2: Installing Libraries

1. Open the Arduino IDE:

If you haven’t installed the Arduino IDE, you can download it from the official Arduino website
(https://www.arduino.cc/en/software).

2. Install the LiquidCrystal I2C library and EEPROM library:

If you haven’t already installed these libraries (used in the previous lab (experiment)), follow
the same steps mentioned in the previous lab manual to install the “LiquidCrystal I2C” and
“EEPROM” libraries.
Step 3: Writing the Arduino Code

1. Open a new Arduino sketch:

 Open the Arduino IDE.

 Click “File” -> “New” to create a new sketch.

2. Write the code for the automatic stopwatch with lap timing and data storage:

#include <Wire.h> // Include the Wire library for I2C communication

#include <LiquidCrystal_I2C.h> // Include the LiquidCrystal I2C library

#include <EEPROM.h> // Include the EEPROM library

LiquidCrystal_I2C lcd(0x27, 16, 2); // Set the LCD address (0x27 for a 16x2 display)

const int startStopButtonPin = 2; // Pin for the Start/Stop button

const int resetButtonPin = 3; // Pin for the Reset button

const int lapButtonPin = 4; // Pin for the Lap button

unsigned long startTime = 0; // Variable to store the start time

unsigned long elapsedTime = 0; // Variable to store the elapsed time

boolean timing = false; // Flag to indicate if timing is active

unsigned long lapTimes[10]; // Array to store lap times (adjust the size as needed)

int lapCount = 0; // Variable to keep track of lap count

int eepromAddress = 0; // Start writing to EEPROM address 0

void setup() {

lcd.init(); // Initialize the LCD

lcd.backlight(); // Turn on the backlight (if available)

lcd.print(“Press Start”);

pinMode(startStopButtonPin, INPUT_PULLUP); // Set the Start/Stop button pin as input

pinMode(resetButtonPin, INPUT_PULLUP); // Set the Reset button pin as input

pinMode(lapButtonPin, INPUT_PULLUP); // Set the Lap button pin as input

// Load lap times from EEPROM

for (int i = 0; i < 10; i++) { // Adjust the loop based on the number of laps you want to store

lapTimes[i] = EEPROMReadInt(eepromAddress);

eepromAddress += sizeof(int);

void loop() {

// Check if the Start/Stop button is pressed

if (digitalRead(startStopButtonPin) == LOW) {

if (!timing) {

startTime = millis(); // Start timing

timing = true;

lcd.clear();

lcd.setCursor(0, 0);

lcd.print(“Timing...”);

} else {

elapsedTime += millis() - startTime; // Stop timing

timing = false;
 lcd.clear();

lcd.setCursor(0, 0);

lcd.print("Press Start");

delay(100); // Debounce

// Check if the Lap button is pressed

if (digitalRead(lapButtonPin) == LOW && timing) {

// Record the lap time

lapTimes[lapCount] = millis() - startTime;

// Write the lap time to EEPROM

EEPROMWriteInt(eepromAddress, lapTimes[lapCount]);

eepromAddress += sizeof(int);

lapCount++;

// Display the lap time on the LCD

lcd.setCursor(0, 2 + lapCount); // Adjust the row based on your LCD size

lcd.print(“Lap”);

lcd.print(lapCount);

lcd.print(“:”);

lcd.print(lapTimes[lapCount - 1] / 1000); // Convert milliseconds to seconds

lcd.print(“s”);

delay(100); // Debounce
 }

// Check if the Reset button is pressed

if (digitalRead(resetButtonPin) == LOW) {

// Reset lap times and clear EEPROM

lapCount = 0;

for (int i = 0; i < eepromAddress; i++) {

EEPROM.write(i, 0);

eepromAddress = 0;

// Reset timing

elapsedTime = 0;

timing = false;

// Clear the LCD

lcd.clear();

lcd.setCursor(0, 0);

lcd.print("Press Start");

delay(100); // Debounce

// Display the elapsed time on the LCD

lcd.setCursor(0, 1);

lcd.print(“Time: ”);

lcd.print(elapsedTime / 1000); // Convert milliseconds to seconds

lcd.print(“s”);

}
// Custom function to read an integer from EEPROM

int EEPROMReadInt(int address) {

byte lowByte = EEPROM.read(address);

byte highByte = EEPROM.read(address + 1);

return (highByte << 8) | lowByte;

// Custom function to write an integer to EEPROM

void EEPROMWriteInt(int address, int value) {

byte lowByte = (byte)(value & 0xFF);

byte highByte = (byte)((value >> 8) & 0xFF);

EEPROM.write(address, lowByte);

EEPROM.write(address + 1, highByte);

1. Upload the code to the Arduino:

 Connect your Arduino to your computer using a USB cable.

 Select the correct Arduino board and port in the "Tools" menu.

 Click the "Upload" button (arrow icon) to upload the code to the Arduino.

Step 4: Testing

1. After uploading the code, press the Start/Stop button to start and stop the stopwatch.

2. Press the Lap button to record lap times. The lap times should be displayed on the
LCD.

3. Press the Reset button to reset the stopwatch to zero and clear the recorded lap times.

4. Observe that the recorded lap times are stored in EEPROM and are retained even
after resetting the Arduino.
 5. Experiment with the stopwatch and explore how it behaves when you start, stop,
reset, and record lap times.

Conclusion

In this lab, you successfully designed an automatic stopwatch with lap timing and data storage
using an Arduino and an I2C LCD display. This enhanced stopwatch is useful for tracking multiple
time intervals and ensures that recorded times are not lost even after power cycles. These features
make it versatile for various timing applications, including sports, experiments, and data
collection.