ir sensor read

 int IR1=9;

int IR2=10;

void setup() {

pinMode(IR1, INPUT);

pinMode(IR2, INPUT);

 Serial.begin(9600);

}

void loop() {

int l = digitalRead(IR1);

int r = digitalRead(IR2);

   

  Serial.print("Sensor Value: ");

  Serial.print(l); Serial.print('-’); Serial.println(r);

}

3 IR sensor Line follower code

 //Arduino Code for Maze Solving Robot Project

//Written by: www.circuitdigest.com

#include <AFMotor.h>  // Include the Adafruit Motor Shield library for motor control

// Motor Definitions

AF_DCMotor motorA(1);  // Motor A connected to terminal M1 on the motor shield

AF_DCMotor motorB(2);  // Motor B connected to terminal M2 on the motor shield

// Sensor Pin Definitions

const int leftSensor = A0;   // Left IR sensor pin

const int frontSensor = A1;  // Front IR sensor pin

const int rightSensor = A2;  // Right IR sensor pin

// Movement Parameters

const int forwardSpeed = 90;  // Speed for forward movement uragshaa hodloh hurd

const int TurningSpeed = 100;  // Speed for turning movements ergeh hodolgoonii hurd

const int turnDelay = 25;      // Delay for completing a turn //ergelt duusah saatal

const int uTurnDelay = 50;    // Delay for completing a U-turn  //

void setup() {

 // Configure sensor pins as input

 pinMode(leftSensor, INPUT);

 pinMode(frontSensor, INPUT);

 pinMode(rightSensor, INPUT);

 // Initialize serial communication for debugging

 Serial.begin(9600);

}

void loop() {

 // Read sensor values (0 or 1)

 int leftValue = digitalRead(leftSensor);

 int frontValue = digitalRead(frontSensor);

 int rightValue = digitalRead(rightSensor);

 // Combine sensor states into a single value for switch-case logic

 int sensorState = (leftValue << 2) | (frontValue << 1) | rightValue;

 // Decision-making based on sensor states

 switch (sensorState) {

   case 0b000:  // No sensors detect a wall

     uTurn();   // Perform a U-turn

     Serial.println("Stop");

     break;

   case 0b010:       // Only the front sensor detects a wall

     moveForward();  // Move forward

     Serial.println("Move Forward");

     break;

   case 0b111:    // All sensors detect walls

     turnLeft();  // Turn left

     Serial.println("Turn Left");

     break;

   case 0b100:    // Only the left sensor detects a wall

     turnLeft();  // Turn left

     Serial.println("Turn Left");

     break;

   case 0b110:    // Front and left sensors detect walls

     turnLeft();  // Turn left

     Serial.println("Turn Left");

     break;

   case 0b001:     // Only the right sensor detects a wall

     turnRight();  // Turn right

     Serial.println("Turn Right");

     break;

   case 0b011:     // Front and right sensors detect walls

     turnRight();  // Turn right

     Serial.println("Turn Right");

     break;

   case 0b101:      // Left and right sensors detect walls

     stopMotors();  // Stop the motors

     Serial.println("Turn Left");

     break;

   default:         // Unknown sensor state

     stopMotors();  // Stop the motors as a safety measure

     Serial.println("Unknown State");

     break;

 }

}

// Function to move forward

void moveForward() {

 motorA.setSpeed(forwardSpeed);  // Set speed for motor A

 motorB.setSpeed(forwardSpeed);  // Set speed for motor B

 motorA.run(FORWARD);            // Move motor A forward

 motorB.run(FORWARD);            // Move motor B forward

}

// Function to turn left

void turnLeft() {

 motorA.setSpeed(TurningSpeed - 20);  // Reduce speed of motor A for smoother turn

 motorB.setSpeed(TurningSpeed);       // Set speed for motor B

 motorA.run(BACKWARD);                // Move motor A backward

 motorB.run(FORWARD);                 // Move motor B forward

 delay(turnDelay);                    // Delay to complete the turn

}

// Function to turn right

void turnRight() {

 motorA.setSpeed(TurningSpeed);       // Set speed for motor A

 motorB.setSpeed(TurningSpeed - 20);  // Reduce speed of motor B for smoother turn

 motorA.run(FORWARD);                 // Move motor A forward

 motorB.run(BACKWARD);                // Move motor B backward

 delay(turnDelay);                    // Delay to complete the turn

}

// Function to stop the motors

void stopMotors() {

 motorA.run(RELEASE);  // Release motor A

 motorB.run(RELEASE);  // Release motor B

}

// Function to perform a U-turn

void uTurn() {

 motorA.setSpeed(TurningSpeed);  // Set speed for motor A

 motorB.setSpeed(TurningSpeed);  // Set speed for motor B

 motorA.run(FORWARD);            // Move motor A forward

 motorB.run(BACKWARD);           // Move motor B backward

 delay(uTurnDelay);              // Delay to complete the U-turn

}

QTR-8A PID Line Follower and L293D

 #include <AFMotor.h> // Motor Shield Library

#include <QTRSensors.h> // QTR Sensor Library

// set to 1kHz PWM frequency

AF_DCMotor motor1(1, MOTOR12_1KHZ); //create motor #1 using M1 output on Motor Drive Shield

AF_DCMotor motor2(2, MOTOR12_1KHZ); //create motor #2 using M2 output on Motor Drive Shield

// note that KP < KD

#define KP 0.02

#define KD 2

#define M1_minimum_speed 150

#define M2_minimum_speed 150

#define M1_maximum_speed 250

#define M2_maximum_speed 250

// speed can be between  0 and 255 - 0 is LOW and 255 is HIGH.

QTRSensors qtr;

const uint8_t sensorCount = 6;

uint16_t sensorValues[sensorCount];

void setup() {

  qtr.setTypeAnalog();

  qtr.setSensorPins((const uint8_t[]){A0, A1, A2, A3, A4, A5}, sensorCount);

  qtr.setEmitterPin(2);

  pinMode(LED_BUILTIN, OUTPUT);

  digitalWrite(LED_BUILTIN, HIGH);

  set_motors(0,0);

  int i;

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

    if (i < 25 || i >= 75) {

      turn_right();

    }

    else {

      turn_left();

    }

    qtr.calibrate();

    delay(20);

  }

  stop();

  digitalWrite(LED_BUILTIN, LOW); // end calibration

  delay(1000);

}

int lastError = 0;

void loop() {

  // read calibrated sensor values and obtain a measure of the line position

  // from 0 to 7000

  uint16_t position = qtr.readLineBlack(sensorValues);

  // for PID

  int error = position - 3500;

  int motorSpeed = KP * error + KD * (error - lastError);

  lastError = error;

  int leftMotorSpeed = M1_minimum_speed + motorSpeed;

  int rightMotorSpeed = M2_minimum_speed - motorSpeed;

  

  // set motor speeds using the two motor speed variables above

  set_motors(leftMotorSpeed, rightMotorSpeed);

}

void set_motors(int motor1speed, int motor2speed) {

  if (motor1speed > M1_maximum_speed) motor1speed = M1_maximum_speed;

  if (motor2speed > M2_maximum_speed) motor2speed = M2_maximum_speed;

  if (motor1speed < 0) motor1speed = 0; 

  if (motor2speed < 0) motor2speed = 0; 

  motor1.run(FORWARD); 

  motor2.run(FORWARD);

  motor1.setSpeed(motor1speed); 

  motor2.setSpeed(motor2speed);

}

void stop() {

  motor1.run(RELEASE);

  motor2.run(RELEASE);

}

void turn_left() {

  motor1.run(BACKWARD);

  motor2.run(FORWARD);

}

void turn_right() {

  motor1.run(FORWARD);

  motor2.run(BACKWARD);

}

2 medregchtei shugam dagadag robot

 #include <AFMotor.h> #define DEBUG_PRINT 0 #define LEFT_IR A0 #define RIGHT_IR A2

#define DETECT_LIMIT 300

#define FORWARD_SPEED 150

#define TURN_SHARP_SPEED 250

#define TURN_SLIGHT_SPEED 200

#define DELAY_AFTER_TURN 140

#define BEFORE_TURN_DELAY 10

AF_DCMotor motorL(1);  

AF_DCMotor motorR(2);  

int left_value;

int right_value;

char lastDirection = 'S';  

void setup() {

#if DEBUG_PRINT  

  Serial.begin(9600);

#endif  

  motorL.setSpeed(0);

  motorL.run(RELEASE);

  motorR.setSpeed(0);

  motorR.run(RELEASE);

  motorR.run(FORWARD);

  motorL.run(FORWARD);

  motorL.setSpeed(255);

  motorR.setSpeed(255);

  delay(40);  

}

void loop() {

  left_value = analogRead(LEFT_IR);

  right_value = analogRead(RIGHT_IR);

#if DEBUG_PRINT

  Serial.print(left_value);

  Serial.print(",");

  Serial.print(right_value);

  Serial.print(",");

  Serial.print(lastDirection);

  Serial.write(10);

#endif

  if (right_value >= DETECT_LIMIT && !(left_value >= DETECT_LIMIT)) {

    turnRight();

  }

  else if ((left_value >= DETECT_LIMIT) && !(right_value >= DETECT_LIMIT)) {

    turnLeft();

  }

  else if (!(left_value >= DETECT_LIMIT) && !(right_value >= DETECT_LIMIT)) {

    moveForward();

  }

  else if ((left_value >= DETECT_LIMIT) && (right_value >= DETECT_LIMIT)) {

    stop();

  }

}

void moveForward() {

  if (lastDirection != 'F') {

    motorR.run(FORWARD);

    motorL.run(FORWARD);

    motorL.setSpeed(255);

    motorR.setSpeed(255);

    lastDirection = 'F';

    delay(20);

  } else {

    motorR.run(FORWARD);

    motorL.run(FORWARD);

    motorL.setSpeed(FORWARD_SPEED);

    motorR.setSpeed(FORWARD_SPEED);

  }

}

void stop() {

  if (lastDirection != 'S') {

    motorR.run(FORWARD);

    motorL.run(FORWARD);

    motorL.setSpeed(255);

    motorR.setSpeed(255);

    lastDirection = 'S';

    delay(40);

  } else {

    motorL.setSpeed(0);

    motorR.setSpeed(0);

    motorL.run(RELEASE);

    motorR.run(RELEASE);

    lastDirection = 'S';

  }

}

void turnRight(void) {

  if (lastDirection != 'R') {

    lastDirection = 'R';

    motorL.setSpeed(0);

    motorR.setSpeed(0);

    delay(BEFORE_TURN_DELAY);

    motorL.run(FORWARD);

    motorR.run(BACKWARD);

    motorL.setSpeed(TURN_SLIGHT_SPEED);

    motorR.setSpeed(TURN_SLIGHT_SPEED);

  } else {

    motorL.run(FORWARD);

    motorR.run(BACKWARD);

    motorL.setSpeed(TURN_SHARP_SPEED);

    motorR.setSpeed(TURN_SHARP_SPEED);

  }

  delay(DELAY_AFTER_TURN);

}

void turnLeft() {

  if (lastDirection != 'L') {

    lastDirection = 'L';

  motorL.setSpeed(0);

  motorR.setSpeed(0);

  delay(BEFORE_TURN_DELAY);

    motorR.run(FORWARD);

    motorL.run(BACKWARD);

    motorL.setSpeed(TURN_SLIGHT_SPEED);

    motorR.setSpeed(TURN_SLIGHT_SPEED);

  } else {

    motorR.run(FORWARD);

    motorL.run(BACKWARD);

    motorL.setSpeed(TURN_SHARP_SPEED);

    motorR.setSpeed(TURN_SHARP_SPEED);

  }

  delay(DELAY_AFTER_TURN);

}