Design and Implementation of an Open-Source Arduino-Based Intelligent System for Real-Time Speed Measurement Using Dual Infrared Sensors

1. Introduction

The measurement and monitoring of the speed of moving objects are important tasks in various engineering and technological applications, including traffic monitoring, industrial automation, motion analysis, and experimental education. In urban environments, speed monitoring is particularly relevant to road safety, especially in areas near schools, hospitals, and pedestrian crossings. In industrial settings, speed measurement can support the monitoring of moving products, conveyor systems, and automated processes. These applications create a need for accessible electronic systems capable of detecting moving objects, estimating their speed, and providing timely information or warning signals.

Recent developments in microcontroller-based technologies have facilitated the design of compact, programmable, and cost-effective electronic monitoring systems. Open-source platforms, particularly Arduino, provide accessible hardware and software environments for integrating sensors, processing measurement signals, and controlling peripheral devices. Previous studies have demonstrated the applicability of Arduino-based systems in home automation, sensor monitoring, electronic measurement, and automated control applications [1,2,3,4,5,7,10,12,13]. The availability of standardized input/output interfaces, software libraries, and development tools makes these platforms suitable for rapid prototyping, experimental research, and educational applications.

Infrared (IR) sensors are frequently employed in electronic systems for detecting the presence and movement of objects without requiring direct physical contact. Their operating principles and performance characteristics have been investigated in studies addressing infrared sensing technologies, object detection, and sensor-based automation [14,16,17,20,29,30,31,32]. Owing to their relatively simple interfacing and compatibility with microcontrollers, IR sensors can be incorporated into monitoring systems that respond to the passage of objects. Their performance, however, depends on factors such as sensor alignment, target reflectivity, ambient illumination, and detection characteristics, which must be considered when designing reliable measurement configurations.

Several studies have investigated the use of infrared sensors and Arduino-based platforms for speed detection and measurement [43] examined an Arduino Uno-based approach to overspeed detection using an infrared sensor [18] investigated an IR-based traffic-light system, illustrating the relevance of infrared detection in traffic-related applications [45] also addressed vehicle speed detection using IR sensors [44] presented an Arduino Uno-based infrared sensor system for average-speed measurement in uniform linear motion experiments, with an emphasis on supporting physics education. Collectively, these studies demonstrate the relevance of combining infrared sensing and microcontroller-based processing for motion-related applications.

Beyond speed monitoring, the integration of microcontrollers with sensors and peripheral devices has been explored in other automated systems, including intelligent braking, electronic taximeters, and sensor-based control applications [8,9,15]. These investigations illustrate the broader potential of programmable electronic architectures for implementing event detection, measurement processing, and automatic responses. Nevertheless, the practical design of a speed-measurement prototype also requires attention to the coordination of sensing elements, timestamp acquisition, speed calculation, information display, and warning mechanisms within a reproducible hardware and software configuration.

A straightforward approach to estimating the average speed of a moving object is to detect its passage at two spatially separated positions. If the distance between the detection points is known, the average speed can be calculated from the elapsed time between the two detection events. In a microcontroller-based implementation, the use of hardware interrupts can facilitate the recording of detection timestamps and reduce dependence on continuous sensor-state polling in the main program loop. This measurement principle provides a practical basis for developing an integrated system that combines object detection, time-interval acquisition, numerical computation, and automatic indication of predefined operating conditions.

Despite the demonstrated potential of Arduino-based sensing systems, an important practical consideration is the integration of these functions into a modular and accessible prototype that can be reproduced and adapted for different experimental scenarios. In particular, combining two infrared sensors with interrupt-based timestamp acquisition, an LCD for real-time speed visualization, and LED and buzzer indicators for threshold-based warnings offers a compact approach to demonstrating the relationship between object motion, time measurement, and automated electronic control. The present study addresses this design objective by developing an open-source Arduino-based system for measuring and monitoring the average speed of moving objects.

The primary objective of this research is to design, implement, and demonstrate a low-cost electronic prototype based on an Arduino Uno R3 microcontroller and two infrared sensors positioned at a fixed separation distance. The system records the detection timestamps, calculates the average speed of a moving object, displays the resulting value on a 16 × 2 liquid crystal display (LCD), and activates visual and audible warnings when the calculated speed exceeds a predefined threshold. In the implemented configuration, the distance between the sensors is 0.1 m, and the warning threshold is set to 30 km/h. The software is developed in C/C++ using the Arduino Integrated Development Environment (IDE), with external hardware interrupts used to register the sensor detection events.

The main contribution of this study is the design and functional integration of object detection, interrupt-based timestamp acquisition, speed calculation, real-time display, and automatic warning generation within a single modular electronic prototype. The developed system was demonstrated under laboratory conditions using battery-powered toy vehicles, moving spheres, and human passage. These demonstrations were intended to establish the basic operational feasibility of the proposed architecture rather than to provide a quantitative assessment of metrological accuracy. Accordingly, the study presents a reproducible design and implementation approach while identifying the need for further validation against calibrated reference instruments.

The remainder of this paper is organized as follows. Section 2 describes the materials and methods, including the electronic components, circuit configuration, and software implementation. Section 3 presents the implementation results and functional demonstrations. Section 4 discusses the findings, practical limitations, and opportunities for further development. Finally, Section 5 summarizes the principal conclusions and outlines potential applications and future research directions.

2. Materials and Methods

The design and implementation of the proposed intelligent digital system for measuring the speed of moving objects involved the integration of several electronic components, including an Arduino Uno R3 microcontroller, infrared (IR) sensors, a buzzer, a liquid crystal display (LCD), a 5 V DC power supply, a breadboard, light-emitting diodes (LEDs), resistors, and jumper wires for establishing the necessary electrical connections [13,14,15]. The coordination and interaction of these components are managed by dedicated software developed in the C++ programming language using the Arduino Integrated Development Environment (IDE).

The primary scientific contribution of this study lies in the design, development, and implementation of an integrated, modular, and cost-effective electronic system based on the open-source Arduino Uno platform for real-time speed measurement and monitoring of various moving objects. The proposed system incorporates two infrared (IR) sensors positioned alongside the object's trajectory at a predefined separation distance. These sensors are interfaced with a microcontroller that utilizes hardware interrupts to capture detection timestamps and calculate the average speed of the moving object over the sensing interval.

The calculated speed is displayed on the LCD, while exceeding a predefined speed threshold automatically triggers visual warnings through LEDs and an audible alarm through the buzzer. This integrated approach combines object detection, time-interval measurement, speed computation, real-time data visualization, and automated warning functions within a single embedded system.

The main significance of the proposed solution lies in the integration of readily available and programmable electronic technologies into a functional, reproducible, and extensible system. The developed prototype was demonstrated under laboratory conditions using different types of moving objects, including battery-powered toy vehicles, moving spheres, and human passage. These demonstrations support the practical feasibility of the proposed system for the tested scenarios.

Furthermore, the modular architecture and open-source development environment provide opportunities for future improvements, functional extensions, and adaptation to a wider range of applications. The proposed system may serve as a foundation for further research and development in embedded systems, automation, motion monitoring, and practical education in electronics and microcontroller programming.

2.1. Arduino Integrated Development Environment (IDE)

The Arduino Integrated Development Environment (IDE) is a software development platform specifically designed for programming Arduino-compatible microcontroller boards, including the Arduino Uno. It was developed to simplify the processes of writing, compiling, and uploading program code to Arduino boards, thereby facilitating the development of embedded electronic applications for users with varying levels of programming and electronics expertise.

One of the principal advantages of the Arduino IDE is its extensive support for software libraries that extend the functionality of microcontroller-based applications. These libraries facilitate the integration and control of various peripheral devices, including sensors, liquid crystal displays (LCDs), wireless communication modules such as Wi-Fi and Bluetooth, electric motors, and other electronic components [3,4,5,6]. By providing reusable software functions and standardized interfaces, these libraries reduce implementation complexity and support efficient application development.

Another important feature of the Arduino IDE is the Serial Monitor, which enables real-time communication between the Arduino board and a connected computer. This functionality allows developers to observe data transmitted by the microcontroller during program execution, thereby supporting software debugging, system monitoring, and the analysis of measurement results. For instance, in an electronic speed-measurement system, the calculated speed values can be transmitted to the Serial Monitor for inspection, facilitating the verification of computational outputs and the identification of potential programming or operational issues.

Furthermore, the Arduino IDE is an open-source development environment supported by an extensive international community of developers, researchers, educators, and electronics enthusiasts. Its open-source architecture encourages continuous software improvement, the development of additional tools and libraries, and adaptation to specific application requirements. This collaborative development model promotes transparency, accessibility, and knowledge sharing, making the Arduino IDE a practical environment for educational, experimental, and research-oriented embedded systems.

2.2. Electronic Circuit Configuration Under Laboratory Conditions

Figure 11. Electrical Wiring Diagram.

Figure 11. Electrical Wiring Diagram.

2.3. Program Code

The program code is developed in the Arduino Integrated Development Environment (IDE) using the C++ programming language, following the programming structure, syntax, and conventions supported by the Arduino Uno platform. The software implementation is based on the electronic circuit configuration and the operational flowchart presented in Figure 13 and Figure 14, respectively. These diagrams provide the foundation for developing the program logic, ensuring consistency between the hardware connections, the measurement algorithm, and the functional requirements of the proposed system for measuring the speed of moving objects.

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

#define SENSOR_1_PIN 2 // INT0

#define SENSOR_2_PIN 3 // INT1

#define BUZZER_PIN 4

#define GREEN_LED 5

#define RED_LED 6

// Timing and state variables

volatile unsigned long timeSensor1 = 0;

volatile unsigned long timeSensor2 = 0;

volatile bool sensor1Triggered = false;

volatile bool sensor2Triggered = false;

unsigned long lastBuzzerActivation = 0;

unsigned long greenLedStartTime = 0;

unsigned long redLedStartTime = 0;

bool buzzerActive = false;

// Configuration constants

const float distanceBetweenSensors = 0.1; // meters

const float speedLimit = 30.0; // km/h

const unsigned long debounceTime = 5000; // 5ms in microseconds

const unsigned long ledTimeout = 300; // 0.3 seconds

const unsigned long buzzerCooldown = 300; // 0.3 seconds cooldown period

float speed_kmh = 0;

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {

lcd.init();

lcd.backlight();

lcd.print(" Speed Gun ");

delay(1500);

lcd.clear();

// Use internal pull-ups if the sensor output is open-collector.

pinMode(SENSOR_1_PIN, INPUT_PULLUP);

pinMode(SENSOR_2_PIN, INPUT_PULLUP);

pinMode(BUZZER_PIN, OUTPUT);

pinMode(GREEN_LED, OUTPUT);

pinMode(RED_LED, OUTPUT);

// Use FALLING edge since INPUT_PULLUP makes the idle state HIGH.

attachInterrupt(digitalPinToInterrupt(SENSOR_1_PIN), sensor1ISR, FALLING);

attachInterrupt(digitalPinToInterrupt(SENSOR_2_PIN), sensor2ISR, FALLING);

digitalWrite(GREEN_LED, LOW);

digitalWrite(RED_LED, LOW);

}

void loop() {

handleSpeedCalculation();

updateBuzzerState();

updateLedState();

}

void handleSpeedCalculation() {

// Copy volatile variables atomically.

noInterrupts();

bool s1 = sensor1Triggered;

bool s2 = sensor2Triggered;

unsigned long t1 = timeSensor1;

unsigned long t2 = timeSensor2;

interrupts();

if (s1 && s2) {

unsigned long timeDifference = t2 - t1;

// Reset triggers for the next measurement

noInterrupts();

sensor1Triggered = false;

sensor2Triggered = false;

interrupts();

if (timeDifference > 1000) { // Valid measurement threshold (1ms)

calculateAndDisplaySpeed(timeDifference);

} else {

showInvalidReading();

}

}

}

void calculateAndDisplaySpeed(unsigned long delta) {

float timeTaken = delta / 1000000.0; // convert microseconds to seconds

float speed_mps = distanceBetweenSensors / timeTaken;

speed_kmh = speed_mps * 3.6;

lcd.setCursor(0, 0);

lcd.print("Speed: ");

lcd.print(speed_kmh, 1);

lcd.print(" km/h ");

handleSpeedIndicator();

}

void handleSpeedIndicator() {

if (speed_kmh <= speedLimit) {

digitalWrite(GREEN_LED, HIGH);

digitalWrite(RED_LED, LOW);

greenLedStartTime = millis();

// Do not trigger the buzzer when within limit.

} else {

digitalWrite(GREEN_LED, LOW);

digitalWrite(RED_LED, HIGH);

redLedStartTime = millis();

// Only activate the buzzer if it hasn't been activated recently.

if (millis() - lastBuzzerActivation >= buzzerCooldown) {

activateBuzzer();

 }

}

}

void activateBuzzer() {

tone(BUZZER_PIN, 1000); // start a 1 kHz tone

lastBuzzerActivation = millis();

buzzerActive = true;

}

void updateBuzzerState() {

// Turn off the buzzer if it's been on for at least 1 second.

if (buzzerActive && (millis() - lastBuzzerActivation >= 1000)) {

noTone(BUZZER_PIN);

buzzerActive = false;

}

}

void updateLedState() {

// Turn off the green LED after the timeout.

if (digitalRead(GREEN_LED) == HIGH && (millis() - greenLedStartTime >= ledTimeout)) {

digitalWrite(GREEN_LED, LOW);

}

// Turn off the red LED after the timeout.

if (digitalRead(RED_LED) == HIGH && (millis() - redLedStartTime >= ledTimeout)) {

digitalWrite(RED_LED, LOW);

 }

}

void showInvalidReading() {

lcd.setCursor(0, 0);

lcd.print(" Invalid! ");

digitalWrite(GREEN_LED, LOW);

digitalWrite(RED_LED, LOW);

}

void sensor1ISR() {

static unsigned long lastTrigger1 = 0;

unsigned long currentTime = micros();

if (currentTime - lastTrigger1 > debounceTime) {

timeSensor1 = currentTime;

sensor1Triggered = true;

// Reset sensor2 flag for a new measurement cycle

sensor2Triggered = false;

lastTrigger1 = currentTime;

}

}

void sensor2ISR() {

static unsigned long lastTrigger2 = 0;

unsigned long currentTime = micros();

// Only record sensor2 if sensor1 has already triggered.

if (sensor1Triggered && (currentTime - lastTrigger2 > debounceTime)) {

timeSensor2 = currentTime;

sensor2Triggered = true;

lastTrigger2 = currentTime;

}

}

3. Results

3.1. Development and Implementation of the Integrated Electronic System

The principal outcome of this study is the design and implementation of an integrated electronic system for the real-time measurement and monitoring of the speed of moving objects using the open-source Arduino Uno R3 platform.

By integrating two infrared (IR) sensors, an Arduino Uno microcontroller-based board, a 16 × 2 liquid crystal display (LCD) with an I²C interface, two light-emitting diodes (LEDs), and an audible buzzer, a functional prototype was developed that combines object detection, signal processing, speed calculation, and automatic warning generation within a single electronic system.

The successful implementation of the prototype demonstrates the practical feasibility of employing readily available, programmable electronic components to develop integrated monitoring systems without requiring complex data-processing equipment.

3.2. Implementation of the Speed-Measurement Method Using Two Infrared Sensors

An important outcome of this study is the implementation of a speed-measurement method based on recording two distinct detection timestamps associated with the passage of a moving object.

The two IR sensors were positioned alongside the object's trajectory, facing the same direction and separated by a fixed distance of 0.1 m.

When the moving object passes in front of the first sensor (IR1), the microcontroller records the corresponding timestamp, (${\mathit{t}}_1$). Subsequently, when the same object passes in front of the second sensor (IR2), the second timestamp, (${\mathit{t}}_2$), is recorded.

The time difference between these two detection events is used to calculate the average speed of the object over the distance separating the sensors:

$$\mathit{v}={\displaystyle \frac{\mathit{d}}{{\mathit{t}}_2-{\mathit{t}}_1}}$$

(3)

where (v) represents the average speed in meters per second (m/s), (d) is the distance between the sensors in meters, and (${\mathit{t}}_1$) and (${\mathit{t}}_2$) are the recorded detection times in seconds.

For the laboratory configuration with a sensor separation of 0.1 m, the speed expressed in kilometers per hour (km/h) is calculated as follows:

$$\mathit{v}={\displaystyle \frac{\mathit{d}}{∆\mathit{t}}}\left[{\displaystyle \frac{\mathit{m}}{\mathit{s}}}\right]={\displaystyle \frac{\mathit{d}}{∆\mathit{t}}}{\displaystyle \frac{\frac{1}{1000}\left[\mathit{k}\mathit{m}\right]}{\frac{1}{3600}\left[\mathit{h}\right]}}={\displaystyle \frac{\mathit{d}}{∆\mathit{t}}}\bullet 3.6\left[{\displaystyle \frac{\mathit{k}\mathit{m}}{\mathit{h}}}\right]=3.6{\displaystyle \frac{\mathit{d}}{∆\mathit{t}}}[{\displaystyle \frac{\mathit{k}\mathit{m}}{\mathit{h}}}$$

(4)

This measurement approach enables the determination of an object's average speed through local detection at two known positions, without requiring the sensors to be installed directly within the object's path of motion.

3.3. Implementation of a Hardware Interrupt-Based Measurement Algorithm

Another technical outcome is the development and implementation of a measurement algorithm programmed in C/C++ using the Arduino Integrated Development Environment (IDE).

The algorithm employs two external hardware interrupts, INT0 and INT1, associated with digital pins D2 and D3 of the Arduino Uno R3, respectively.

Detection timestamps are recorded using the Arduino micros() function, while the subsequent processing and speed calculations are performed within the main program.

This interrupt-based approach allows the microcontroller to respond to sensor activation events without relying exclusively on continuous sensor-state polling within the main execution loop.

The algorithm also incorporates time-based mechanisms for filtering repeated sensor activations, identifying invalid measurement intervals, and controlling the visual and audible warning devices.

This implementation demonstrates the practical application of microcontrollers in event-driven measurement systems requiring time-interval acquisition and processing.

3.4. Measurement Display and Automatic Warning Indication

The implemented system enables the calculated speed to be displayed on a 16 × 2 LCD through the I²C communication interface.

In addition to numerical visualization, an automatic comparison mechanism was implemented to evaluate the calculated speed against a predefined threshold established in the program.

When the measured speed remains within the permitted limit, the green LED is activated. Conversely, when the speed exceeds the predefined threshold, the red LED and audible buzzer are activated.

In the implemented configuration, the speed threshold was set to 30 km/h.

This functionality enables the system to perform not only speed measurement but also automatic monitoring and warning generation without requiring continuous operator intervention.

3.5. Functional Demonstration Under Laboratory Conditions

The functionality of the developed prototype was demonstrated under laboratory conditions by moving different objects in front of the two infrared sensors.

Battery-powered toy vehicles, moving spheres, and human passage were used to demonstrate the operation of the system.

During these demonstrations, the system performed object detection, recorded the corresponding time intervals, calculated and displayed the speed values, and activated the appropriate warning indicators according to the predefined speed threshold.

These observations support the functional feasibility of the proposed system for the categories of moving objects included in the laboratory demonstrations.

However, these demonstrations do not constitute a quantitative assessment of metrological accuracy, as no numerical comparison with a calibrated reference instrument was presented in this study.

Consequently, although the prototype demonstrates the integration and operation of the proposed measurement and warning functions, further experimental investigations are required to establish its measurement accuracy, repeatability, and reliability under different operating conditions.

3.6. System Modularity and Reproducibility

Another outcome of this study is the development of a modular system architecture in which the sensors, microcontroller, display, and warning devices perform distinct but coordinated functions through software-based control.

The use of the Arduino Uno R3, standard electronic components, and the Arduino IDE facilitates the documentation and reproduction of the prototype by researchers, students, and other developers.

The program code can be adapted to modify the distance between the sensors, the predefined speed threshold, the timing parameters, and the warning mechanisms according to specific experimental requirements.

This modular architecture provides a practical foundation for further system extensions, including measurement data storage, wireless communication, remote monitoring, and additional data-processing capabilities.

Furthermore, the separation of sensing, processing, visualization, and warning functions supports future modifications without requiring a complete redesign of the electronic system.

3.7. Summary of the Main Results

The results of this study demonstrate the feasibility of developing an integrated electronic system for measuring the speed of moving objects using the Arduino Uno platform and infrared sensors.

The principal contribution is the demonstration of the functional integration of object detection, timestamp acquisition, speed calculation, measurement visualization, and automatic warning generation within a single programmable electronic architecture.

The developed prototype and its accompanying technical documentation provide a foundation for further experimental investigations, educational applications, and potential adaptations to specialized motion-monitoring systems.

Although the laboratory demonstrations confirmed the basic operational functionality of the prototype, additional quantitative validation is necessary to determine its measurement accuracy and suitability for applications requiring higher levels of precision and operational reliability.

4. Discussion

The findings of this study demonstrate the functional feasibility of an integrated electronic system for the real-time measurement and monitoring of moving-object speed, developed using the open-source Arduino Uno R3 platform. The integration of two infrared (IR) sensors, a microcontroller-based processing unit, a liquid crystal display (LCD), and visual and audible signaling devices enabled the development of a modular and cost-effective prototype that combines object detection, speed calculation, measurement visualization, and automatic warning generation within a single electronic architecture.

A key feature of the proposed system is the placement of two IR sensors alongside the object's trajectory, separated by a fixed distance of 0.1 m. This configuration enables the average speed of a moving object to be determined by measuring the time interval between two consecutive detection events. The use of the microcontroller's hardware interrupts and the micros() function facilitates timestamp acquisition and subsequent processing without relying on continuous sensor-state polling within the main program loop.

In addition to speed measurement, the system provides automatic warning indications when the calculated speed exceeds a configurable threshold, which was set to 30 km/h in this study. The integration of visual indicators through LEDs and audible notifications through a buzzer demonstrates the feasibility of implementing a system that not only calculates the speed of moving objects but also responds automatically to predefined conditions established within the control algorithm.

Laboratory demonstrations involving battery-powered toy vehicles, moving spheres, and human passage confirmed the operation of the basic detection, calculation, and warning mechanisms under the tested conditions. Nevertheless, the present study primarily focused on system design and functional integration and did not include a statistical evaluation of measurement accuracy or an experimental comparison with calibrated reference instruments. Therefore, the observed functionality should not be interpreted as evidence of validated measurement precision or reliability across different operating environments.

From a practical perspective, the modular architecture and the use of open-source technologies facilitate system reproducibility, modification, and further development. The principal limitations are associated with variations in ambient lighting conditions, the reflective properties of moving objects, sensor positioning and alignment, and the acquisition of short time intervals between detection events. These factors may influence detection consistency and the accuracy of the calculated speed. Future research should therefore focus on algorithm optimization, quantitative assessment of measurement accuracy and repeatability, data storage capabilities, and the integration of wireless communication technologies.

In conclusion, the proposed system represents a functional and extensible approach to monitoring the speed of moving objects. The principal contribution of this study lies in the design and implementation of an integrated, reproducible, and economically accessible electronic architecture. The developed prototype provides a practical foundation for educational and laboratory applications, as well as for further research and development of specialized motion-monitoring systems.

5. Conclusions

Potential Applications and Future Development of the Proposed System

The proposed scientific and innovative approach integrates hardware and software components to develop an intelligent digital system for measuring the speed of moving objects using an Arduino Uno R3 microcontroller-based platform and two infrared (IR) sensors. The system also incorporates additional electronic components, including light-emitting diodes (LEDs), an audible buzzer, electrical jumper wires, resistors, and a liquid crystal display (LCD).

The integration of these components provides a foundation for developing a programmable speed-measurement and monitoring system with potential applications in several fields. The principal applications and opportunities for further development are outlined below:

• Urban traffic speed monitoring: The system could be further developed for measuring and monitoring vehicle speeds in urban traffic environments where speed restrictions are imposed for road safety and other regulatory considerations.
• Driver warning and awareness: By incorporating visual displays and warning indicators, the system could provide drivers with information when their vehicle speed exceeds the legally permitted limit, potentially contributing to increased awareness of speed restrictions.
• Engineering education and laboratory training: The prototype can be used as an educational platform for students to design, implement, test, and discuss embedded electronic systems under controlled laboratory conditions, thereby strengthening their practical understanding of sensors, microcontrollers, and software-based control.
• Hardware expansion and system enhancement: The modular architecture enables the integration of additional hardware components to extend the functionality and capabilities of the proposed intelligent digital system.
• Software modification and adaptation: The program code can be modified, optimized, or extended according to changes in the electronic configuration, the addition of peripheral devices, or new functional requirements.
• Athletic performance monitoring: With appropriate modifications, the system could be adapted to measure an athlete's running speed and determine the time required to reach a predefined destination in a sports environment.
• Bowling ball speed measurement: The system could be adapted to measure the speed of a bowling ball after release and display the calculated value on an electronic screen. Such functionality could provide additional information to players and spectators, potentially increasing engagement and encouraging discussion of performance.
• Industrial conveyor speed monitoring: The proposed measurement principle could be adapted to determine the movement speed of products transported along conveyor systems within industrial production facilities, where monitoring product movement is relevant to process control.
• Product counting in manufacturing processes: By using a single IR sensor and appropriately modifying the software algorithm, the system could be configured to detect and count individual products passing a specified point along a factory conveyor line.
• Adaptation to new engineering requirements: The electronic configuration and program code can be modified to accommodate additional sensors, communication modules, processing functions, and application-specific requirements, supporting the development of new intelligent electronic systems.
• Educational and research potential: Beyond its immediate functionality, the proposed system can serve as a practical foundation for students, electronics enthusiasts, engineers, and researchers interested in developing more advanced embedded systems. Its accessible architecture may encourage experimentation, innovation, and the application of microcontroller-based technologies across different scientific, industrial, and socioeconomic domains.

Overall, the proposed system demonstrates the potential of combining affordable electronic components and programmable control technologies to develop flexible and extensible monitoring solutions. Although its current implementation has been demonstrated primarily under laboratory conditions, the modular design provides opportunities for further research, experimental validation, and adaptation to more demanding real-world applications.