Unit 6: Intelligent Systems - Subjective Questions

Arduino Uno is an open-source microcontroller development board based on the ATmega328P microcontroller. It is used to receive inputs from sensors, process the input programmatically, and control output devices.

In an IR sensor-based detection system, the Arduino Uno performs the following functions:

• Supplies power to the IR sensor through its and ground pins.
• Reads the digital or analog output of the IR sensor.
• Compares the sensor signal with a programmed condition.
• Activates an output such as an LED, buzzer, motor, or display.
• Provides decision-making capability, making the system an intelligent detection unit.

Thus, the Arduino acts as the control and processing unit between the IR sensor and the output device.

The important Arduino Uno features used in an IR detection system are:

• Microcontroller: ATmega328P, which executes the control program.
• Digital input/output pins: Fourteen pins, numbered 0 to 13, are available for reading sensor signals and controlling outputs.
• Analog input pins: Six pins, A0 to A5, can measure varying sensor voltages.
• PWM pins: Pins marked with a tilde () can generate pulse-width-modulated outputs.
• Operating voltage: The board generally operates at .
• USB interface: Used for programming and serial communication with a computer.
• Power options: It can be powered through USB or an external supply.
• Digital resolution: A digital input recognizes logic LOW or HIGH, while the analog-to-digital converter generally provides a -bit range from to .

These features allow the Arduino to interface easily with an IR sensor and suitable indication devices.

An IR obstacle detection sensor works by transmitting infrared radiation and detecting the radiation reflected from an object.

The working sequence is:

• An IR LED emits infrared light, usually near a wavelength of .
• If an object is present in front of the sensor, some of the emitted radiation is reflected.
• A photodiode or phototransistor receives the reflected radiation.
• The sensor circuit converts the received light into an electrical signal.
• A comparator may convert this signal into a digital HIGH or LOW output.
• The Arduino reads the output and determines whether an object has been detected.

The detected distance depends on object color, reflectivity, angle, ambient light, and the sensor design. Dark or non-reflective objects may produce a weaker reflected signal.

Digital and analog interfacing differ in the type of information supplied to the Arduino.

For digital operation, the detection condition can be written as:

Digital interfacing is simpler, whereas analog interfacing provides more information and requires threshold selection in software.

A typical IR sensor module has three terminals: VCC, GND, and OUT. The connections may be made as follows:

• Connect VCC of the IR module to the Arduino 5 V pin.
• Connect GND of the module to an Arduino GND pin.
• Connect OUT of the module to a digital input pin, such as pin 2.
• Connect the anode of an LED to a digital output pin, such as pin 13, through a current-limiting resistor.
• Connect the LED cathode to ground.

A resistor is required to limit LED current. Its approximate value can be calculated using:

For example, with a output, a LED drop, and a desired current of , the resistor is approximately . A standard value such as may be used.

The program should initialize the sensor as an input and the LED and buzzer as outputs. It should then repeatedly read the sensor and operate the indicators.

Program logic:

• Set the IR sensor pin as INPUT.
• Set the LED and buzzer pins as OUTPUT.
• Read the IR sensor using digitalRead().
• If the sensor indicates an object, turn on the LED and buzzer.
• Otherwise, turn both devices off.
• Repeat the process continuously.

A representative algorithm is:

1. Start.
2. Initialize input and output pins.
3. Read the sensor state.
4. Test whether the sensor state represents detection.
5. Turn on the indicators if detection is true.
6. Turn off the indicators if detection is false.
7. Return to Step 3.

The exact HIGH/LOW condition depends on the sensor module's output logic and must be verified experimentally.

The following example uses an IR sensor connected to pin 2, an LED connected to pin 13, and a buzzer connected to pin 8. It assumes that the sensor output becomes LOW when an object is detected.

const int irPin = 2;
const int ledPin = 13;
const int buzzerPin = 8;

void setup() {
  pinMode(irPin, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
}

void loop() {
  int sensorState = digitalRead(irPin);

  if (sensorState == LOW) {
    digitalWrite(ledPin, HIGH);
    digitalWrite(buzzerPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
    digitalWrite(buzzerPin, LOW);
  }

  delay(50);
}

Explanation:

• pinMode() configures input and output pins.
• digitalRead() obtains the sensor state.
• The if statement checks the detection condition.
• digitalWrite() controls the LED and buzzer.
• The delay reduces unnecessary rapid switching.

If the module produces HIGH during detection, the condition must be changed to sensorState == HIGH.

Arduino programs contain two essential functions: setup() and loop().

setup() function:

• Executes only once when the Arduino is powered or reset.
• Configures sensor pins as inputs.
• Configures LED, buzzer, or relay pins as outputs.
• Initializes serial communication if debugging is required.
• Establishes the initial state of output devices.

loop() function:

• Executes repeatedly after setup() finishes.
• Reads the IR sensor continuously.
• Applies the programmed detection condition.
• Controls the output devices according to the sensor state.
• Allows the system to respond to changing objects in real time.

For an intelligent detection system, all monitoring and decision-making operations generally occur inside loop().

Sensor calibration is the process of adjusting the sensor or its program so that it gives the desired response under specified conditions.

An IR sensor can be calibrated using the following procedure:

• Place the sensor in the intended operating environment.
• Keep the target object at the required detection distance.
• Adjust the module's potentiometer until the detection indicator changes at the desired point.
• Test the sensor with and without an object.
• Repeat the test for different object colors and positions.
• If analog output is used, record the sensor readings and select a suitable software threshold.
• Verify that the sensor does not trigger when the object is absent.

Calibration must consider ambient light, surface reflectivity, object distance, and sensor alignment. Proper calibration improves reliability and reduces false detections.

The accuracy of an IR detection system is affected by several electrical and environmental factors:

• Object color: Dark surfaces reflect less infrared radiation than light surfaces.
• Object material: Shiny, transparent, or rough materials reflect infrared light differently.
• Distance: The reflected intensity generally decreases as the object moves farther away.
• Alignment: Incorrect angle between the sensor and object may reduce reflected radiation.
• Ambient light: Sunlight and strong lamps can interfere with the photodetector.
• Power supply: Voltage fluctuations can change sensor output.
• Electrical noise: Motors and long wires can introduce unwanted signals.
• Threshold setting: An unsuitable comparator or software threshold causes missed detections or false alarms.
• Mechanical vibration: Movement can change the sensor-object geometry.

Reliability can be improved using shielding, proper calibration, stable power, short connections, filtering, and suitable mounting.

An LED must be connected with a series resistor to limit current. Applying Kirchhoff's voltage law to the output circuit gives:

Rearranging,

For an Arduino output of , a red LED forward voltage of , and desired current of :

A standard resistor value of should be selected. The actual current is then approximately:

This value is safe for the LED and generally suitable for an Arduino indicator circuit. The selected current must also remain within the Arduino pin's recommended limits.

IR transmitter:

• Usually an infrared LED.
• Converts electrical current into infrared radiation.
• Emits the signal or illumination needed for detection.

IR receiver:

• Usually a photodiode or phototransistor.
• Converts received infrared radiation into an electrical signal.
• Produces an output related to the intensity of received light.

IR sensor module:

• Combines an IR transmitter, receiver, signal-conditioning circuit, and often a comparator.
• May include a potentiometer for threshold adjustment.
• Commonly provides VCC, GND, and digital OUT terminals.
• Can directly interface with an Arduino digital input.

Therefore, the transmitter emits radiation, the receiver detects it, and the module processes both functions to provide a usable detection output.

An intelligent detection system does more than merely sense an electrical signal; it interprets the signal and takes an appropriate action.

The Arduino-based process is:

• The IR sensor observes the surrounding object or obstacle.
• The sensor generates a digital or analog electrical signal.
• The Arduino samples the signal through an input pin.
• A program compares the reading with a specified condition or threshold.
• The Arduino classifies the condition, such as object present or object absent.
• It controls an actuator or indicator according to the classification.
• It may also record the event, transmit data, or count detections.

For an analog reading and threshold :

This sensing, processing, and action sequence forms the basis of an intelligent embedded system.

The simple circuit is suitable for basic detection, while the Arduino system is more adaptable and capable of intelligent control.

Serial communication allows the Arduino to send sensor readings and system messages to a computer through the USB connection.

The testing procedure is:

• Start serial communication in setup() using a suitable baud rate, such as Serial.begin(9600).
• Read the sensor state or analog value in loop().
• Send the value using Serial.println().
• Open the Serial Monitor in the Arduino IDE.
• Observe readings when the object is present and absent.
• Use the readings to determine the correct logic level or analog threshold.

Serial monitoring helps identify:

• Incorrect wiring.
• Reversed detection logic.
• Unstable sensor output.
• Inadequate detection distance.
• Incorrect calibration.

It is a useful diagnostic tool because the sensor behavior can be observed without relying only on an LED or buzzer.

Common faults and remedies include:

• No sensor output: Check VCC, GND, and OUT connections and verify the power supply.
• LED does not glow: Confirm pin selection, LED polarity, resistor connection, and program logic.
• Buzzer remains continuously ON: Check whether the sensor logic is active LOW instead of active HIGH.
• False detection: Adjust the sensor potentiometer, reduce ambient light, improve alignment, or use software filtering.
• Unstable readings: Use a stable supply, common ground, shorter wires, and repeated sampling.
• Arduino program does not upload: Check the selected board, port, USB cable, and bootloader settings.
• Sensor works only at a short distance: Adjust calibration and examine target color and reflectivity.
• Component damage: Avoid short circuits and do not connect LEDs without current-limiting resistors.

Systematic testing should proceed from the power supply to the sensor, input pin, program logic, and output devices.

An IR sensor output may change rapidly due to noise, object vibration, or borderline detection. This can cause an LED or buzzer to switch repeatedly. Software filtering reduces this unwanted behavior.

One simple method is time confirmation:

• Read the sensor repeatedly.
• Accept a detection only if the same state remains for a specified time.
• Ignore very short pulses.

Another method is multiple-sample filtering:

• Take readings.
• Count the number of detection readings.
• Declare detection if the count exceeds a selected limit.

For example, if and at least readings indicate an object, the detection decision is accepted. A time-based condition can be expressed as:

Filtering improves stability but may introduce a small response delay, so the delay must be selected according to the application.

When an analog IR sensor is connected to an Arduino analog input, the Arduino's ADC converts the input voltage into a numerical value. For a -bit ADC and a reference voltage of , the approximate input voltage is:

where is the ADC reading from to .

The program compares the reading with a selected threshold :

The threshold is determined experimentally by recording readings with and without an object. A margin between the two ranges should be selected to avoid unstable operation. If the sensor response decreases when an object is detected, the comparison direction must be reversed.

A systematic implementation procedure is as follows:

1. Define the requirement: Specify the object, detection distance, response time, and desired output.
2. Select components: Choose an Arduino Uno, IR sensor module, LED, buzzer, resistors, wires, and a suitable power source.
3. Prepare the circuit: Connect VCC and GND correctly and connect the sensor output to an Arduino input.
4. Connect indicators: Wire the LED through a resistor and connect the buzzer to an output pin.
5. Develop the algorithm: Decide how sensor readings will be interpreted and what actions will follow.
6. Write and upload the program: Configure pins and implement continuous sensing.
7. Test individual sections: Check the supply, sensor output, input reading, and indicators separately.
8. Calibrate the sensor: Adjust distance and threshold settings.
9. Improve reliability: Add filtering, shielding, stable mounting, or timing logic.
10. Document the system: Record the circuit, program, calibration settings, and test results.

This process reduces errors and produces a dependable detection system.

Important safety and protection precautions include:

• Verify the supply voltage before connecting the Arduino and sensor.
• Connect the grounds of the Arduino and sensor correctly.
• Avoid short circuits between power and ground.
• Use a series resistor with every discrete LED.
• Do not exceed the recommended current of an Arduino I/O pin.
• Use a transistor or driver circuit when controlling a high-current load.
• Disconnect power before changing circuit connections.
• Check component polarity, especially for LEDs, diodes, electrolytic capacitors, and buzzers.
• Keep conductive objects away from the powered circuit.
• Use a regulated supply and suitable decoupling if the circuit is unstable.
• Protect the USB port and computer from external voltage sources.

These precautions prevent component damage, unreliable operation, and possible hazards during workshop implementation.