├── Project Report.pdf
├── README.md
├── Robot-Line_Following
    └── Robot-Line_Following.ino
├── Robot-Obstacle
    └── Robot-Obstacle.ino
├── arduino-icon.svg
├── arduino-ide-logo.svg
├── myRobot
    └── myRobot.ino
├── myRobotX
    └── myRobotX.ino
├── newlineFollower
    └── newlineFollower.ino
└── readme-essentials
    ├── LIFOD.jfif
    ├── LIFOD.jpg
    ├── RAD Doc.docx
    ├── RAD lf.png
    ├── RAD oa1.png
    ├── RAD oa2.png
    └── ~$AD Doc.docx


/Project Report.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/noel319/Arduino-Robot/cfe593d5743f8b30175152b90b757df060bbf393/Project Report.pdf


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | <div align="center">
 3 |   <p>
 4 |       <img width="20%" src="/arduino-icon.svg">
 5 |   </p>
 6 |   <b><h3> Arduino Robot </h3></b>
 7 |   <p> Making Line Followign & Object Avoiding Robot using <a href="https://www.arduino.cc"> Arduino </a></p>
 8 | </div>
 9 | <br>
10 | 
11 | <br>
12 | 
13 | ## Instructions:
14 | - All Files of Robot
15 | - Testing Files Also included
16 | - myRobot code is made by our own hand
17 | - [compounents](#items-we-used) are mentioned below
18 | - [newlineFollower](/newlineFollower) just included the Line Following code
19 | - <b>[myRobotX](/myRobotX) is the Final Code</b>
20 | 
21 | <br><br>
22 | 
23 | ## Items we used
24 | 1. [Arduino Uno R3](https://store.arduino.cc/products/arduino-uno-rev3)
25 | 2. [L298 Motor Driver](https://components101.com/modules/l293n-motor-driver-module)
26 | 3. Car chassis pack 
27 | 4. Battries
28 | 5. Wheels
29 | 6. Ultra Sonic Sensor
30 | 7. Infared Sensors
31 | 8. Servo Motor
32 | 9. Bread Board
33 | 10. Jumpers
34 | 
35 | <br>
36 | 
37 | ## Apps and Tools
38 |  &nbsp;  &nbsp; <a href="https://www.arduino.cc/en/software"><img src="/arduino-ide-logo.svg" width="40"></a>
39 | 
40 | <br>
41 | 
42 | ## How It follows the line
43 | <br>
44 |   <img src="/readme-essentials/RAD lf.png" width="600">
45 |  &nbsp;&nbsp;&nbsp;&nbsp;
46 |  A) Both IR LEDs are on the line. Robot car should move forward. 
47 |  <br><br>&nbsp;&nbsp;&nbsp;&nbsp;
48 |  B) The Right IR LED is on the line while the left deviates to the left. Robot car should turn to the right. 
49 |  <br><br>&nbsp;&nbsp;&nbsp;&nbsp;
50 |  C) The Left IR LED is on the line while the right deviates to the right. Robot car should turn to the left. 
51 |  <br>
52 |  
53 | <br><br>
54 | 
55 | ## How It avoids obstacles
56 | <br>
57 |   The basic principle behind the working of ultrasonic sensor is to note down the time  <br>
58 |   taken by sensor to transmit ultrasonic beams and receiving the ultrasonic beams after <br>
59 |   hitting the surface. Then further the distance is calculated.
60 | <br><br>
61 |   <img src="/readme-essentials/RAD oa1.png" width="600">
62 | <br>
63 |   <img src="/readme-essentials/RAD oa2.png" width="600">
64 | 
65 | <br><br>
66 | 
67 | ## Special Thanks:
68 | - [Tharusha Perera](https://github.com/tharusha1004)
69 | - [Pruthuvi De Silva](https://github.com/PruthuviDe)
70 | - [Yasiru Ravishan](https://github.com/yasiruravishan24)
71 | 
72 | <br>
73 | 
74 | ## Checkout Our Documentation:
75 | [Project Proposal](/Project%20Report.pdf)
76 | 
77 | <br><br>
78 | ---
79 | 
80 | <div align="center">
81 | <img src="/readme-essentials/LIFOD.jpg" width="300" height="auto">
82 | 
83 | LinkedIn Post: [click here!](https://www.linkedin.com/posts/janith-disanayake-8511b0240_team-robot-roboticsengineering-activity-6954856546669400064-tL5p?utm_source=linkedin_share&utm_medium=member_desktop_web)
84 | 
85 | </div>
86 | 
87 | 


--------------------------------------------------------------------------------
/Robot-Line_Following/Robot-Line_Following.ino:
--------------------------------------------------------------------------------
  1 | 
  2 | const int LeftF = 11; // orange
  3 | const int LeftR = 10; // yello
  4 | const int RightF = 6; // green
  5 | const int RightR = 5; // blue
  6 | 
  7 | const int IRl = 9;  //white
  8 | const int IRr = 8;  //purple
  9 | const int IRm = 7;  //blue
 10 | 
 11 | #define echo 4  //yello
 12 | #define trig 3  //green
 13 | 
 14 | void setup() {
 15 |   pinMode(LeftF, OUTPUT);
 16 |   pinMode(RightF, OUTPUT);
 17 |   pinMode(LeftR, OUTPUT);
 18 |   pinMode(RightR, OUTPUT);
 19 | 
 20 |   pinMode(IRl,INPUT);
 21 |   pinMode(IRr,INPUT);
 22 |   pinMode(IRm,INPUT);
 23 | 
 24 |   Serial.begin(9600);  
 25 | }
 26 | 
 27 | void loop() {
 28 |   int x = digitalRead(IRl);
 29 |   int y = digitalRead(IRr);
 30 |   int z = digitalRead(IRm);
 31 | 
 32 |   if(digitalRead(IRl)==HIGH && digitalRead(IRr)==HIGH) //IR will not glow on black line
 33 |   {
 34 |     Stop();
 35 |   }
 36 | 
 37 |   else if(digitalRead(IRl)==LOW && digitalRead(IRr)==LOW)  //IR not on black line
 38 |   {
 39 |     Forward();
 40 |   }
 41 | 
 42 |   else if(digitalRead(IRl)==LOW && digitalRead(IRr)==HIGH)
 43 |   {
 44 |     turnRight();
 45 |     delay(10);
 46 |   }
 47 | 
 48 |   else if(digitalRead(IRl)==HIGH && digitalRead(IRr)==LOW)
 49 |   {
 50 |     turnLeft();
 51 |     delay(10);
 52 |   }
 53 | 
 54 |   else
 55 |   {
 56 |     Stop();
 57 |   }
 58 | }
 59 | 
 60 | 
 61 | void Forward()
 62 | {
 63 |     Serial.println("Forward");
 64 |   analogWrite(LeftF, 100);
 65 |   analogWrite(RightF, 100);
 66 |   analogWrite(LeftR, 0);
 67 |   analogWrite(RightR, 0);
 68 | }
 69 | 
 70 | void Reverse()
 71 | {
 72 |   Serial.println("Reverse");
 73 |   analogWrite(LeftR, 100);
 74 |   analogWrite(RightR, 100);
 75 |   analogWrite(LeftF, 0);
 76 |   analogWrite(RightF, 0);
 77 | }
 78 | 
 79 | void turnRight()
 80 | {
 81 |   
 82 |   Serial.println("Right");
 83 |   analogWrite(LeftF, 100);
 84 |   analogWrite(LeftR, 0);
 85 |   analogWrite(RightR, 0); 
 86 |   analogWrite(RightF, 0);
 87 |   
 88 | }
 89 | 
 90 | void turnLeft()
 91 | {
 92 |   
 93 |   Serial.println("Left");
 94 |   analogWrite(LeftF, 0);
 95 |   analogWrite(LeftR, 0);
 96 |   analogWrite(RightR, 0); 
 97 |   analogWrite(RightF, 100);
 98 | }
 99 | 
100 | 
101 | void Stop()
102 | {
103 |   Serial.println("Stop");
104 |   analogWrite(LeftF, 0);
105 |   analogWrite(LeftR, 0); 
106 |   analogWrite(RightF, 0);
107 |   analogWrite(RightR, 0);
108 | }
109 | 


--------------------------------------------------------------------------------
/Robot-Obstacle/Robot-Obstacle.ino:
--------------------------------------------------------------------------------
  1 | #include <Servo.h>
  2 | 
  3 | Servo myservo;
  4 | 
  5 | const int LeftF = 11; // orange
  6 | const int LeftR = 10; // yello
  7 | const int RightF = 6; // green
  8 | const int RightR = 5; // blue
  9 | 
 10 | const int IRl = 9;  //white
 11 | const int IRr = 8;  //purple
 12 | const int IRm = 7;  //blue
 13 | 
 14 | #define echo 4  //yello
 15 | #define trig 3  //green
 16 | 
 17 | void setup() {
 18 |   Serial.begin(9600);
 19 | 
 20 |   pinMode(trig, OUTPUT);
 21 |   pinMode(echo, INPUT);
 22 | 
 23 |   pinMode(LeftF, OUTPUT);
 24 |   pinMode(RightF, OUTPUT);
 25 |   pinMode(LeftR, OUTPUT);
 26 |   pinMode(RightR, OUTPUT);
 27 | 
 28 |   myservo.attach(2); int x = digitalRead(IRl);
 29 |   int y = digitalRead(IRr);
 30 | 
 31 | 
 32 |   if (detectObj())
 33 |   { turnUSsensorMiddle();
 34 |     obstacleDetector();
 35 |   }
 36 |   else
 37 |   { Forward();
 38 |   }
 39 | }
 40 | 
 41 | void loop()
 42 | {
 43 | 
 44 | 
 45 | }
 46 | 
 47 | void obstacleDetector()
 48 | {
 49 |   Stop();
 50 |   turnUSsensorMiddle();
 51 |   delay(3000);
 52 | 
 53 |   if (detectObj())
 54 |   { turnUSsensorLeft();
 55 |     delay(1000);
 56 |     if (detectObj())
 57 |     { turnUSsensorMiddle();
 58 |       Stop();
 59 |       delay(100);
 60 |     }
 61 |     else
 62 |     { offRoadL();
 63 |     }
 64 |   }
 65 |   else
 66 |   { Forward();
 67 |     delay(100);
 68 |   }
 69 | }
 70 | 
 71 | 
 72 | void Forward()
 73 | { Serial.println("Forward");
 74 |   analogWrite(LeftF, 100);
 75 |   analogWrite(RightF, 100);
 76 |   analogWrite(LeftR, 0);
 77 |   analogWrite(RightR, 0);
 78 | }
 79 | 
 80 | void turnLeft()
 81 | { Serial.println("Left");
 82 |   analogWrite(LeftF, 0);
 83 |   analogWrite(LeftR, 0);
 84 |   analogWrite(RightR, 0);
 85 |   analogWrite(RightF, 100);
 86 | }
 87 | 
 88 | void turnRight()
 89 | { Serial.println("Right");
 90 |   analogWrite(LeftF, 100);
 91 |   analogWrite(LeftR, 0);
 92 |   analogWrite(RightR, 0);
 93 |   analogWrite(RightF, 0);
 94 | }
 95 | 
 96 | void Reverse()
 97 | { Serial.println("Reverse");
 98 |   analogWrite(LeftR, 150);
 99 |   analogWrite(RightR, 150);
100 |   analogWrite(LeftF, 0);
101 |   analogWrite(RightF, 0);
102 | }
103 | 
104 | void Stop()
105 | { Serial.println("Stop");
106 |   analogWrite(LeftF, 0);
107 |   analogWrite(LeftR, 0);
108 |   analogWrite(RightF, 0);
109 |   analogWrite(RightR, 0);
110 | }
111 | 
112 | void turnUSsensorLeft()
113 | { Serial.println("sensor turned left");
114 |   myservo.write(135);
115 | }
116 | 
117 | void turnUSsensorRight()
118 | { Serial.println("sensor turned right");
119 |   myservo.write(2);
120 | }
121 | 
122 | void turnUSsensorMiddle()
123 | { Serial.println("sensor turned middle");
124 |   myservo.write(90);
125 | }
126 | 
127 | bool detectLineIRm()
128 | { int z = digitalRead(IRm);
129 |   if (z == 1)
130 |   { return true;
131 |   }
132 |   else
133 |   { return false;
134 |   }
135 | }
136 | 
137 | void offRoadL()
138 | { turnUSsensorMiddle();
139 |   delay(500);
140 |   while (detectObj())
141 |   { turnLeft();
142 |     delay(50);
143 |     Stop();
144 |     delay(50);
145 |   }
146 |   while (detectObjDistance() > 20) {
147 |     turnUSsensorRight();
148 |     delay(1000);
149 |     Forward();
150 |     delay(50);
151 |     Stop();
152 |     delay(50);
153 |   }
154 |   delay(1000);
155 |   turnUSsensorRight();
156 |   delay(500);
157 |   while (!detectLineIRm ())
158 |   { if (detectObjDistance() < 20) {
159 |       turnLeft();
160 |       Serial.println(detectObjDistance());
161 |     }
162 |     else if (detectObjDistance() > 30) {
163 |       turnRight();
164 |       Serial.println(detectObjDistance());
165 |     }
166 |     else if (detectObjDistance() > 20 && detectObjDistance() < 30)
167 |     { Forward(); Serial.println(detectObjDistance());
168 |     }
169 |   }
170 | }
171 | 
172 | void offRoadR()
173 | {
174 |   turnUSsensorMiddle();
175 |   while (detectObj())
176 |   { turnRight();
177 |   }
178 |   turnUSsensorLeft();
179 |   while (!detectLineIRm())
180 |   { if (detectObjDistance() < 20) {
181 |       turnRight();
182 |       Serial.println(detectObjDistance());
183 |     }
184 |     else if (detectObjDistance() > 30) {
185 |       turnLeft();
186 |       Serial.println(detectObjDistance());
187 |     }
188 |     else if (detectObjDistance() > 20 && detectObjDistance() < 30)
189 |     { Forward(); Serial.println(detectObjDistance());
190 |     }
191 |   }
192 | 
193 | }
194 | 
195 | bool detectObj()
196 | { digitalWrite(trig, HIGH);
197 |   delayMicroseconds(10);
198 |   digitalWrite(trig, LOW);
199 |   unsigned long t = pulseIn(echo, HIGH); //microseconds
200 |   float d = 340.0 * (t / 1000000.0) / 2 * 100; //cm
201 |   Serial.println(d);
202 |   if (d < 35)
203 |   { return true;
204 |   }
205 |   else
206 |   { return false;
207 |   }
208 | }
209 | 
210 | int detectObjDistance()
211 | { digitalWrite(trig, HIGH);
212 |   delayMicroseconds(10);
213 |   digitalWrite(trig, LOW);
214 |   unsigned long t = pulseIn(echo, HIGH); //microseconds
215 |   float d = 340.0 * (t / 1000000.0) / 2 * 100; //cm
216 |   return d;
217 | }
218 | 


--------------------------------------------------------------------------------
/arduino-icon.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 32 32" preserveAspectRatio="xMidYMid" fill="#00979c"><path d="M23.783 23.55c-2.044 0-3.8-.7-5.33-2.1-.95-.87-1.733-1.937-2.454-3.046-.72 1.1-1.504 2.175-2.454 3.046-1.653 1.515-3.547 2.197-5.8 2.087C3.476 23.52 0 20.143 0 15.994c0-4.16 3.495-7.544 7.8-7.544a8.51 8.51 0 0 1 6.05 2.378c.826.77 1.524 1.66 2.16 2.593.636-.933 1.334-1.824 2.16-2.593a8.51 8.51 0 0 1 6.05-2.378c4.296 0 7.8 3.384 7.8 7.544 0 4.148-3.476 7.526-7.755 7.544a9.39 9.39 0 0 1-.462.011zm-6.22-7.656c.853 1.383 1.68 2.67 2.688 3.594 1.138 1.043 2.337 1.472 3.887 1.4l.07-.002c2.827 0 5.128-2.2 5.128-4.88s-2.3-4.88-5.128-4.88a5.88 5.88 0 0 0-4.236 1.665c-.912.848-1.665 1.935-2.408 3.116zM7.8 11.113c-2.827 0-5.128 2.2-5.128 4.88s2.3 4.88 5.128 4.88l.07.002c1.55.082 2.75-.347 3.887-1.4 1.008-.924 1.836-2.2 2.688-3.594-.744-1.18-1.497-2.268-2.408-3.116C10.817 11.63 9.47 11.1 7.8 11.1zm16.762 3.914v-1.444H23.06v1.444h-1.444v1.496h1.444v1.455h1.503v-1.455h1.444v-1.496h-1.444M5.628 15h4.746v1.542H5.628z"/></svg>


--------------------------------------------------------------------------------
/arduino-ide-logo.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" width="2499" height="2500" viewBox="0 0 1372.201 1372.684"><path fill="#00979D" stroke="#81C9CB" stroke-width=".932" stroke-miterlimit="10" d="M1371.701 686.024c0 378.658-306.972 685.605-685.549 685.605C307.451 1371.629.5 1064.682.5 686.024.5 307.455 307.451.483 686.152.483c378.594.001 685.549 306.972 685.549 685.541z"/><linearGradient id="a" gradientUnits="userSpaceOnUse" x1="-16.3" y1="16.071" x2="1354.901" y2="16.071" gradientTransform="matrix(1 0 0 -1 16.8 702.696)"><stop offset=".117" stop-color="#fff" stop-opacity="0"/><stop offset=".252" stop-color="#c0d1d3" stop-opacity=".153"/><stop offset=".387" stop-color="#91b3b7" stop-opacity=".306"/><stop offset=".52" stop-color="#6d9fa3" stop-opacity=".457"/><stop offset=".65" stop-color="#4d9195" stop-opacity=".604"/><stop offset=".776" stop-color="#30888b" stop-opacity=".746"/><stop offset=".895" stop-color="#148386" stop-opacity=".881"/><stop offset="1" stop-color="#008184"/></linearGradient><linearGradient id="b" gradientUnits="userSpaceOnUse" x1="-16.8" y1="16.071" x2="1355.401" y2="16.071" gradientTransform="matrix(1 0 0 -1 16.8 702.696)"><stop offset="0" stop-color="#fff" stop-opacity="0"/><stop offset=".153" stop-color="#c0d1d3" stop-opacity=".153"/><stop offset=".306" stop-color="#91b3b7" stop-opacity=".306"/><stop offset=".457" stop-color="#6d9fa3" stop-opacity=".457"/><stop offset=".604" stop-color="#4d9195" stop-opacity=".604"/><stop offset=".746" stop-color="#30888b" stop-opacity=".746"/><stop offset=".881" stop-color="#148386" stop-opacity=".881"/><stop offset="1" stop-color="#008184"/></linearGradient><path opacity=".5" fill="url(#a)" stroke="url(#b)" stroke-miterlimit="10" d="M1371.701 686.595c0 378.65-306.972 685.606-685.549 685.606C307.451 1372.201.5 1065.23.5 686.595.5 308.019 307.451 1.048 686.152 1.048c378.594.016 685.549 306.97 685.549 685.547z"/><g fill="#FFF"><path d="M947.959 931.196c-12.909 0-26.127-.929-39.127-2.864-108.978-15.554-181.848-93.822-222.665-153.989-40.946 60.166-113.811 138.512-222.74 154.045a275.864 275.864 0 0 1-39.133 2.785c-67.753 0-131.358-25.217-179.201-71.003-48.299-46.165-74.951-108.114-74.951-174.171 0-66.14 26.651-128.004 75.021-174.253 47.797-45.793 111.449-70.936 179.231-70.936 12.918 0 26.067.928 39.023 2.783 108.932 15.535 181.794 93.813 222.743 153.99 40.825-60.177 113.689-138.432 222.658-153.99 13-1.863 26.148-2.783 39.066-2.783 67.753 0 131.401 25.208 179.197 70.936 48.345 46.249 74.937 108.113 74.937 174.253 0 66.057-26.524 128.006-74.868 174.171-47.881 45.785-111.434 71.026-179.191 71.026M734.42 686.024c21.283 40.534 84.067 141.676 186.692 156.375 8.984 1.236 18.028 1.923 26.839 1.923 92.185 0 167.225-71.002 167.225-158.322s-75.023-158.321-167.291-158.321c-8.812 0-17.853.629-26.753 1.921-102.644 14.664-165.428 115.806-186.712 156.424M424.393 527.702c-92.308 0-167.36 70.998-167.36 158.321 0 87.305 75.021 158.322 167.245 158.322 8.852 0 17.897-.688 26.879-1.922 102.629-14.697 165.394-115.783 186.689-156.375-21.237-40.535-84.061-141.761-186.689-156.376-8.877-1.341-17.945-1.97-26.764-1.97"/><path d="M354.37 662.051h152.625v49.181H354.37zM1016.484 662.051h-51.671v-51.747h-49.348v51.747h-51.648v49.181h51.648v51.737h49.348v-51.737h51.671z"/></g></svg>


--------------------------------------------------------------------------------
/myRobot/myRobot.ino:
--------------------------------------------------------------------------------
  1 | #include <Servo.h>
  2 | 
  3 | #define SPEED 120
  4 | 
  5 | #define echo 4  //yello
  6 | #define trig 3  //green
  7 | 
  8 | Servo myservo;
  9 | const int servoPin = 2; // orange
 10 | 
 11 | const int LeftF = 11; // orange
 12 | const int LeftR = 10; // yello
 13 | const int RightF = 6; // green
 14 | const int RightR = 5; // blue
 15 | 
 16 | const int IRl = A2;  //white
 17 | const int IRm = A1;  //blue
 18 | const int IRr = A0;  //purple
 19 | 
 20 | 
 21 | 
 22 | void setup() {
 23 |   Serial.begin(9600);  
 24 | 
 25 |   pinMode(trig, OUTPUT);
 26 |   pinMode(echo, INPUT);
 27 |   
 28 |   pinMode(LeftF, OUTPUT);
 29 |   pinMode(RightF, OUTPUT);
 30 |   pinMode(LeftR, OUTPUT);
 31 |   pinMode(RightR, OUTPUT);
 32 | 
 33 |   pinMode(IRl,INPUT);
 34 |   pinMode(IRr,INPUT);
 35 |   pinMode(IRm,INPUT);
 36 | 
 37 |   myservo.attach(servoPin);
 38 | }
 39 | 
 40 | void loop() 
 41 | { 
 42 |   int x = digitalRead(IRl);
 43 |   int y = digitalRead(IRm);
 44 |   int z = digitalRead(IRr);
 45 | 
 46 |   if(x == HIGH && z == LOW)
 47 |   { turnLeft();
 48 |     delay(10);
 49 |   }
 50 |   else if(x == LOW &&  z == HIGH)
 51 |   { turnRight();
 52 |     delay(10);
 53 |   }
 54 |   else if (x == HIGH &&  z == HIGH && y==HIGH)
 55 |   { Stop();
 56 |     delay(500);
 57 |     turnRight(); 
 58 |     delay(100);
 59 |     Stop();
 60 |     delay(100);     
 61 |   }
 62 |   else if (x == LOW &&  z == LOW && y==LOW){
 63 |       Stop();   
 64 |   }
 65 |   else
 66 |   { Forward();
 67 |   }
 68 |   
 69 |   if(detectObj())
 70 |   { turnUSsensorMiddle();
 71 |     obstacleDetector();
 72 |   }
 73 |   else
 74 |   { Forward();
 75 |   }
 76 |   
 77 | }
 78 | 
 79 | void obstacleDetector()
 80 | {
 81 |   Stop();
 82 |   turnUSsensorMiddle();  
 83 |   delay(3000);
 84 |   
 85 |   if(detectObj())
 86 |   { turnUSsensorLeft();
 87 |     delay(1000);
 88 |     if(detectObj())
 89 |     { turnUSsensorMiddle();
 90 |       Stop();
 91 |       delay(100);
 92 |     }
 93 |     else
 94 |     { offRoadL();
 95 |     }
 96 |   }
 97 |   else
 98 |   { Forward();
 99 |     delay(100);
100 |   }
101 | }
102 | 
103 | 
104 | void Forward()
105 | { Serial.println("Forward");
106 |   analogWrite(LeftF, SPEED);
107 |   analogWrite(RightF, SPEED);
108 |   analogWrite(LeftR, 0);
109 |   analogWrite(RightR, 0);
110 | }
111 | 
112 | void turnLeft()
113 | { Serial.println("Left");
114 |   analogWrite(LeftF, 0);
115 |   analogWrite(LeftR, 0);
116 |   analogWrite(RightR, 0); 
117 |   analogWrite(RightF, SPEED);
118 | }
119 | 
120 | void turnRight()
121 | { Serial.println("Right");
122 |   analogWrite(LeftF, SPEED);
123 |   analogWrite(LeftR, 0);
124 |   analogWrite(RightR, 0); 
125 |   analogWrite(RightF, 0);
126 | }
127 | 
128 | void Reverse()
129 | { Serial.println("Reverse");
130 |   analogWrite(LeftR, SPEED);
131 |   analogWrite(RightR, SPEED);
132 |   analogWrite(LeftF, 0);
133 |   analogWrite(RightF, 0);
134 | }
135 | 
136 | void Stop()
137 | { Serial.println("Stop");
138 |   analogWrite(LeftF, 0);
139 |   analogWrite(LeftR, 0); 
140 |   analogWrite(RightF, 0);
141 |   analogWrite(RightR, 0);
142 | }
143 | 
144 | void turnUSsensorLeft()
145 | { Serial.println("sensor turned left");
146 |   myservo.write(135);
147 | }
148 | 
149 | void turnUSsensorRight()
150 | {  Serial.println("sensor turned right");
151 |    myservo.write(2);
152 | }
153 | 
154 | void turnUSsensorMiddle()
155 | { Serial.println("sensor turned middle");
156 |   myservo.write(90);
157 | }
158 | 
159 | bool detectLineIR()
160 | { int z = digitalRead(IRr);
161 |   if(z==1)
162 |   { return true;    
163 |   }
164 |   else
165 |   { return false;
166 |   }
167 | }
168 | 
169 | void offRoadL()
170 | { turnUSsensorMiddle();
171 |   delay(500);
172 |   while(detectObj())
173 |   { turnLeft();
174 |     delay(50);
175 |     Stop();
176 |     delay(50);
177 |   }
178 |   
179 |   turnLeft();
180 |   delay(50);
181 |   Stop();
182 |   delay(50);
183 |   
184 |   while(detectObjDistance()>20){
185 |     turnUSsensorRight();
186 |     delay(100);
187 |     Forward();
188 |     delay(100); 
189 |     Stop();
190 |     delay(10);   
191 |   }  
192 |   delay(1000);
193 |   turnUSsensorRight();
194 |   delay(500);
195 |   while(!detectLineIRm())
196 |   { if(detectObjDistance()<20)
197 |     { turnLeft();delay(100);
198 |       stop_Stop();delay(50);
199 |       Serial.println(detectObjDistance());
200 |     }
201 |     else if(detectObjDistance()>30)
202 |     { turnRight();delay(100);
203 |       stop_Stop();delay(50);
204 |       Serial.println(detectObjDistance());
205 |     }
206 |     else if(detectObjDistance()>20 && detectObjDistance()<30)
207 |     { Forward();Serial.println(detectObjDistance());
208 |     }
209 |   }turnUSsensorMiddle(); 
210 | }
211 | 
212 | //void offRoadR()
213 | //{
214 | //  turnUSsensorMiddle();
215 | //  while(detectObj())
216 | //  { turnRight();
217 | //  }
218 | //  turnUSsensorLeft();
219 | //  while(!detectLineIR())
220 | //  { if(detectObjDistance()<20){turnRight();Serial.println(detectObjDistance());}
221 | //    else if(detectObjDistance()>30){turnLeft();Serial.println(detectObjDistance());}
222 | //    else if(detectObjDistance()>20 && detectObjDistance()<30)
223 | //    { Forward();Serial.println(detectObjDistance());
224 | //    }
225 | //  }
226 | //  
227 | //}
228 | 
229 | bool detectObj()
230 | { digitalWrite(trig,HIGH);
231 |   delayMicroseconds(10);
232 |   digitalWrite(trig,LOW);
233 |   unsigned long t = pulseIn(echo,HIGH); //microseconds
234 |   float d = 340.0*(t/1000000.0)/2 *100; //cm
235 |   Serial.println(d);
236 |   if(d<35)
237 |   { return true;
238 |   }
239 |   else
240 |   { return false;
241 |   }
242 | }
243 | 
244 | int detectObjDistance()
245 | { digitalWrite(trig,HIGH);
246 |   delayMicroseconds(10);
247 |   digitalWrite(trig,LOW);
248 |   unsigned long t = pulseIn(echo,HIGH); //microseconds
249 |   float d = 340.0*(t/1000000.0)/2 *100; //cm  
250 |   return d;
251 | }
252 | 


--------------------------------------------------------------------------------
/myRobotX/myRobotX.ino:
--------------------------------------------------------------------------------
  1 | #include <Servo.h>
  2 | #include <NewPing.h>
  3 | 
  4 | #define speedPinR 5
  5 | #define RightMotorDirPin1 4
  6 | #define RightMotorDirPin2 7
  7 | #define speedPinL 6
  8 | #define LeftMotorDirPin1 8
  9 | #define LeftMotorDirPin2 12
 10 | 
 11 | #define SERVO_PIN 10
 12 | 
 13 | #define Echo_PIN 2
 14 | #define Trig_PIN 3
 15 | 
 16 | #define SPEED1 130
 17 | #define SPEED2 120
 18 | #define SPEED3 100
 19 | 
 20 | #define max_dist 150
 21 | #define stop_range 10
 22 | #define stop_wait 4
 23 | 
 24 | #define IRSensorL A2
 25 | #define IRSensorM A1
 26 | #define IRSensorR A0
 27 | 
 28 | #define buzzer 13
 29 | 
 30 | int cm;
 31 | bool turning;
 32 | int counter;
 33 | 
 34 | 
 35 | NewPing sonar(Trig_PIN, Echo_PIN, max_dist);
 36 | Servo myservo;
 37 | 
 38 | void setup() {
 39 | 
 40 |   pinMode(RightMotorDirPin1, OUTPUT);
 41 |   pinMode(RightMotorDirPin2, OUTPUT);
 42 |   pinMode(speedPinL, OUTPUT);
 43 | 
 44 |   pinMode(LeftMotorDirPin1, OUTPUT);
 45 |   pinMode(LeftMotorDirPin2, OUTPUT);
 46 |   pinMode(speedPinR, OUTPUT);
 47 | 
 48 |   pinMode(Trig_PIN, OUTPUT);
 49 |   pinMode(Echo_PIN, INPUT);
 50 | 
 51 |   pinMode(IRSensorL, INPUT);
 52 |   pinMode(IRSensorM, INPUT);
 53 |   pinMode(IRSensorR, INPUT);
 54 | 
 55 |   pinMode(buzzer, OUTPUT);
 56 | 
 57 | 
 58 |   myservo.attach(SERVO_PIN);
 59 |   myservo.write(85);
 60 |   delay(200);
 61 | 
 62 |   Serial.begin(9600);
 63 | 
 64 |   stop_Stop();
 65 | //  counter = 0;
 66 | }
 67 | 
 68 | void loop() {
 69 |   
 70 |   
 71 | //  int counter2 = 0;
 72 | //  cm = readDistance();
 73 | //  Serial.println(cm);
 74 | 
 75 |   int x = digitalRead(IRSensorL);
 76 |   int y = digitalRead(IRSensorR);
 77 | 
 78 |   
 79 |   if(detectObj())
 80 |   { turnUSsensorMiddle();
 81 |     obstacleDetector();
 82 |   }
 83 |   else
 84 |   { followLine();
 85 |   }
 86 | }
 87 | 
 88 | 
 89 | void followLine() {
 90 | 
 91 |   int valueLeft = digitalRead(IRSensorL);
 92 |   int valueRight = digitalRead(IRSensorR);
 93 |   int valueMiddle = digitalRead(IRSensorM);
 94 | 
 95 |   if ((valueLeft == HIGH && valueRight == LOW )) {
 96 |     go_Left();delay(10);
 97 |     stop_Stop();delay(10);
 98 |   } else if ((valueLeft == LOW &&  valueRight == HIGH)) {
 99 |     go_Right();delay(10);
100 |     stop_Stop();delay(10);
101 |   } else if (valueLeft == HIGH &&  valueRight == HIGH && valueMiddle == HIGH) {
102 |     go_Right();
103 |   } else if (valueLeft == LOW &&  valueRight == LOW && valueMiddle == LOW) {
104 |     turn_back();
105 |   }
106 |   else {
107 |     go_Advance();
108 |   }
109 | }
110 | 
111 | //Set Motor Speed
112 | void set_Motorspeed(char g) {
113 |   if (g == 'L' || g == 'R' || g == 'S') {
114 |     analogWrite(speedPinL, SPEED2);
115 |     analogWrite(speedPinR, SPEED2);
116 |   }else if(g == 'T'){
117 |     analogWrite(speedPinL, SPEED3);
118 |     analogWrite(speedPinR, SPEED3);
119 |   }
120 |   else {
121 |     analogWrite(speedPinL, SPEED1);
122 |     analogWrite(speedPinR, SPEED1);
123 |   }
124 | 
125 | }
126 | 
127 | //Read Ultrasonic Sensor
128 | int readDistance() {
129 |   int cm = sonar.ping_cm();
130 |   return cm;
131 | }
132 | 
133 | void go_Advance() {
134 |   digitalWrite(RightMotorDirPin1, LOW);
135 |   digitalWrite(RightMotorDirPin2, HIGH);
136 |   digitalWrite(LeftMotorDirPin1, LOW);
137 |   digitalWrite(LeftMotorDirPin2, HIGH);
138 |   set_Motorspeed('A');
139 | }
140 | void go_Right() {
141 |   digitalWrite(RightMotorDirPin1, LOW);
142 |   digitalWrite(RightMotorDirPin2, HIGH);
143 |   digitalWrite(LeftMotorDirPin1, HIGH);
144 |   digitalWrite(LeftMotorDirPin2, LOW);
145 |   set_Motorspeed('R');
146 | }
147 | 
148 | void go_Left() {
149 |   digitalWrite(RightMotorDirPin1, HIGH);
150 |   digitalWrite(RightMotorDirPin2, LOW);
151 |   digitalWrite(LeftMotorDirPin1, LOW);
152 |   digitalWrite(LeftMotorDirPin2, HIGH);
153 |   set_Motorspeed('L');
154 | }
155 | 
156 | void stop_Stop() {
157 |   digitalWrite(RightMotorDirPin1, LOW);
158 |   digitalWrite(RightMotorDirPin2, LOW);
159 |   digitalWrite(LeftMotorDirPin1, LOW);
160 |   digitalWrite(LeftMotorDirPin2, LOW);
161 |   set_Motorspeed('S');
162 | }
163 | 
164 | void turn_back() {
165 |   digitalWrite(RightMotorDirPin1, LOW);
166 |   digitalWrite(RightMotorDirPin2, HIGH);
167 |   digitalWrite(LeftMotorDirPin1, HIGH);
168 |   digitalWrite(LeftMotorDirPin2, LOW);
169 |   set_Motorspeed('T');
170 | }
171 | 
172 | void obstacleDetector()
173 | {
174 |   stop_Stop();                
175 |   turnUSsensorMiddle();       
176 |   delay(3000);                
177 |   
178 |   if(detectObj())             
179 |   { turnUSsensorLeft();       
180 |     delay(1000);              
181 |     if(detectObj())           
182 |     { turnUSsensorMiddle();   
183 |       stop_Stop();            
184 |       delay(100);             
185 |     }
186 |     else
187 |     { offRoadL();             
188 |     }
189 |   }
190 |   else
191 |   { go_Advance();
192 |     delay(100);
193 |   }
194 | }
195 | 
196 | void turnUSsensorLeft()
197 | { Serial.println("sensor turned left");
198 |   myservo.write(135);
199 | }
200 | 
201 | void turnUSsensorRight()
202 | {  Serial.println("sensor turned right");
203 |    myservo.write(2);
204 | }
205 | 
206 | void turnUSsensorMiddle()
207 | { Serial.println("sensor turned middle");
208 |   myservo.write(90);
209 | }
210 | 
211 | 
212 | void offRoadL()
213 | { turnUSsensorMiddle();         
214 |   delay(500);
215 |   while(detectObj())
216 |   { go_Right();
217 |     delay(50);
218 |     stop_Stop();
219 |     delay(50);
220 |   }
221 |   
222 |   go_Right();
223 |   delay(50);
224 |   stop_Stop();
225 |   delay(50);
226 |   
227 |   while(detectObjDistance()>20)
228 |   { turnUSsensorRight();
229 |     delay(100);
230 |     go_Advance();
231 |     delay(100);
232 |     stop_Stop();
233 |     delay(10);
234 |   }
235 |   delay(1000);
236 |   turnUSsensorRight();
237 |   delay(500);
238 |   while(!detectLineIRm())
239 |   { if(detectObjDistance()<20)
240 |     { go_Right();delay(100);
241 |       go_Advance();delay(20);
242 |       stop_Stop();delay(50);
243 |       Serial.println(detectObjDistance());
244 |     }
245 |     else if(detectObjDistance()>30)
246 |     { go_Left();delay(100);
247 |       go_Advance();delay(20);
248 |       stop_Stop();delay(50);
249 |       Serial.println(detectObjDistance());
250 |     }
251 |     else if(detectObjDistance()>20 && detectObjDistance()<30)
252 |     { go_Advance();delay(100);
253 |       stop_Stop();delay(50);
254 |       Serial.println(detectObjDistance());
255 |     }
256 |   }turnUSsensorMiddle();   
257 | }
258 | 
259 | bool detectObj()
260 | { digitalWrite(Trig_PIN,HIGH);
261 |   delayMicroseconds(10);
262 |   digitalWrite(Trig_PIN,LOW);
263 |   unsigned long t = pulseIn(Echo_PIN,HIGH); //microseconds
264 |   float d = 340.0*(t/1000000.0)/2 *100; //cm
265 |   Serial.println(d);
266 |   if(d<25)
267 |   { return true;
268 |   }
269 |   else
270 |   { return false;
271 |   }
272 | }
273 | 
274 | int detectObjDistance()
275 | { digitalWrite(Trig_PIN,HIGH);
276 |   delayMicroseconds(10);
277 |   digitalWrite(Trig_PIN,LOW);
278 |   unsigned long t = pulseIn(Echo_PIN,HIGH); //microseconds
279 |   float d = 340.0*(t/1000000.0)/2 *100; //cm  
280 |   return d;
281 | }
282 | 
283 | bool detectLineIRm()
284 | { int z = digitalRead(IRSensorM);
285 |   if(z==1)
286 |   { return true;    
287 |   }
288 |   else
289 |   { return false;
290 |   }
291 | }
292 | 


--------------------------------------------------------------------------------
/newlineFollower/newlineFollower.ino:
--------------------------------------------------------------------------------
  1 | #include <Servo.h>
  2 | #include <NewPing.h>
  3 | 
  4 | #define speedPinR 5
  5 | #define RightMotorDirPin1 4
  6 | #define RightMotorDirPin2 7
  7 | #define speedPinL 6
  8 | #define LeftMotorDirPin1 8
  9 | #define LeftMotorDirPin2 12
 10 | 
 11 | #define SERVO_PIN 10
 12 | 
 13 | #define Echo_PIN 2
 14 | #define Trig_PIN 3
 15 | 
 16 | #define SPEED1 130
 17 | #define SPEED2 110
 18 | #define SPEED3 100
 19 | 
 20 | #define max_dist 150
 21 | #define stop_range 10
 22 | #define stop_wait 4
 23 | 
 24 | #define IRSensorL A2
 25 | #define IRSensorM A1
 26 | #define IRSensorR A0
 27 | 
 28 | #define buzzer 13
 29 | 
 30 | int cm;
 31 | bool turning;
 32 | int counter;
 33 | 
 34 | 
 35 | NewPing sonar(Trig_PIN, Echo_PIN, max_dist);
 36 | Servo servo;
 37 | 
 38 | void setup() {
 39 | 
 40 |   pinMode(RightMotorDirPin1, OUTPUT);
 41 |   pinMode(RightMotorDirPin2, OUTPUT);
 42 |   pinMode(speedPinL, OUTPUT);
 43 | 
 44 |   pinMode(LeftMotorDirPin1, OUTPUT);
 45 |   pinMode(LeftMotorDirPin2, OUTPUT);
 46 |   pinMode(speedPinR, OUTPUT);
 47 | 
 48 |   pinMode(Trig_PIN, OUTPUT);
 49 |   pinMode(Echo_PIN, INPUT);
 50 | 
 51 |   pinMode(IRSensorL, INPUT);
 52 |   pinMode(IRSensorM, INPUT);
 53 |   pinMode(IRSensorR, INPUT);
 54 | 
 55 |   pinMode(buzzer, OUTPUT);
 56 | 
 57 | 
 58 |   servo.attach(SERVO_PIN);
 59 |   servo.write(85);
 60 |   delay(200);
 61 | 
 62 |   Serial.begin(9600);
 63 | 
 64 |   stop_Stop();
 65 |   counter = 0;
 66 | }
 67 | 
 68 | void loop() {
 69 |   
 70 |   
 71 |   int counter2 = 0;
 72 |   cm = readDistance();
 73 | 
 74 |   Serial.println(cm);
 75 | 
 76 |   if (cm <= stop_range && cm != 0) {
 77 |     digitalWrite(buzzer, HIGH);
 78 |     delay(500);
 79 |     digitalWrite(buzzer, LOW);
 80 |     counter++;
 81 |   }
 82 | 
 83 |   if (counter >= stop_wait) {
 84 |     counter = 0;
 85 |     stop_Stop();
 86 |     turning = true;
 87 | 
 88 |     go_Right();
 89 |     delay(380);
 90 |     stop_Stop();
 91 |     delay(500);
 92 |     servo.write(0);
 93 |     delay(500);
 94 | 
 95 |     while (turning) {
 96 |       delay(100);
 97 |       cm = readDistance();
 98 |       if (cm < 20 && cm != 0) {
 99 |         go_Advance();
100 |         delay(50);
101 |         stop_Stop();
102 |       }
103 |       else {
104 |         counter2++;
105 |       }
106 |       if (counter2 > 10) {
107 |         go_Advance();
108 |         delay(500);
109 |         stop_Stop();
110 |         turning = false;
111 |       }
112 |     }
113 | 
114 |     go_Left();
115 |     delay(310);
116 |     go_Advance();
117 |     delay(500);
118 |     stop_Stop();
119 |     delay(500);
120 |     turning = true;
121 |     counter2 = 0;
122 | 
123 |     while (turning) {
124 |       delay(100);
125 |       cm = readDistance();
126 |       if (cm < 20 && cm != 0) {
127 |         go_Advance();
128 |         delay(50);
129 |         stop_Stop();
130 |       }
131 |       else {
132 |         counter2++;
133 |       }
134 |       if (counter2 > 10) {
135 |         go_Advance();
136 |         delay(500);
137 |         stop_Stop();
138 |         turning = false;
139 |       }
140 |     }
141 |     go_Left();
142 |     delay(305);
143 |     stop_Stop();
144 |     delay(500);
145 |     turning = true;
146 | 
147 |     while (turning) {
148 |       int valueLeft = digitalRead(IRSensorL);
149 |       int valueRight = digitalRead(IRSensorR);
150 |       if (valueLeft == LOW || valueRight == LOW) {
151 |         go_Advance();
152 |         delay(50);
153 |         stop_Stop();
154 |       } else { // line found
155 |         turning = false;
156 |         go_Right();
157 |         delay(300);
158 |         stop_Stop();
159 |         servo.write(103);
160 |       }
161 |     }
162 |   } else {
163 |     followLine();
164 |   }
165 | }
166 | 
167 | 
168 | void followLine() {
169 | 
170 |   int valueLeft = digitalRead(IRSensorL);
171 |   int valueRight = digitalRead(IRSensorR);
172 |   int valueMiddle = digitalRead(IRSensorM);
173 | 
174 |   if ((valueLeft == HIGH && valueRight == LOW )) {
175 |     go_Left();
176 |   } else if ((valueLeft == LOW &&  valueRight == HIGH)) {
177 |     go_Right();
178 |   } else if (valueLeft == HIGH &&  valueRight == HIGH && valueMiddle == HIGH) {
179 |     go_Right();
180 |   } else if (valueLeft == LOW &&  valueRight == LOW && valueMiddle == LOW) {
181 |     turn_back();
182 |   }
183 |   else {
184 |     go_Advance();
185 |   }
186 | }
187 | 
188 | //Set Motor Speed
189 | void set_Motorspeed(char g) {
190 |   if (g == 'L' || g == 'R' || g == 'S') {
191 |     analogWrite(speedPinL, SPEED2);
192 |     analogWrite(speedPinR, SPEED2);
193 |   }else if(g == 'T'){
194 |     analogWrite(speedPinL, SPEED3);
195 |     analogWrite(speedPinR, SPEED3);
196 |   }
197 |   else {
198 |     analogWrite(speedPinL, SPEED1);
199 |     analogWrite(speedPinR, SPEED1);
200 |   }
201 | 
202 | }
203 | 
204 | //Read Ultrasonic Sensor
205 | int readDistance() {
206 |   int cm = sonar.ping_cm();
207 |   return cm;
208 | }
209 | 
210 | void go_Advance() {
211 |   digitalWrite(RightMotorDirPin1, LOW);
212 |   digitalWrite(RightMotorDirPin2, HIGH);
213 |   digitalWrite(LeftMotorDirPin1, LOW);
214 |   digitalWrite(LeftMotorDirPin2, HIGH);
215 |   set_Motorspeed('A');
216 | }
217 | void go_Right() {
218 |   digitalWrite(RightMotorDirPin1, LOW);
219 |   digitalWrite(RightMotorDirPin2, HIGH);
220 |   digitalWrite(LeftMotorDirPin1, HIGH);
221 |   digitalWrite(LeftMotorDirPin2, LOW);
222 |   set_Motorspeed('R');
223 | }
224 | 
225 | void go_Left() {
226 |   digitalWrite(RightMotorDirPin1, HIGH);
227 |   digitalWrite(RightMotorDirPin2, LOW);
228 |   digitalWrite(LeftMotorDirPin1, LOW);
229 |   digitalWrite(LeftMotorDirPin2, HIGH);
230 |   set_Motorspeed('L');
231 | }
232 | 
233 | void stop_Stop() {
234 |   digitalWrite(RightMotorDirPin1, LOW);
235 |   digitalWrite(RightMotorDirPin2, LOW);
236 |   digitalWrite(LeftMotorDirPin1, LOW);
237 |   digitalWrite(LeftMotorDirPin2, LOW);
238 |   set_Motorspeed('S');
239 | }
240 | 
241 | void turn_back() {
242 |   digitalWrite(RightMotorDirPin1, LOW);
243 |   digitalWrite(RightMotorDirPin2, HIGH);
244 |   digitalWrite(LeftMotorDirPin1, HIGH);
245 |   digitalWrite(LeftMotorDirPin2, LOW);
246 |   set_Motorspeed('T');
247 | }
248 | 


--------------------------------------------------------------------------------
/readme-essentials/LIFOD.jfif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/noel319/Arduino-Robot/cfe593d5743f8b30175152b90b757df060bbf393/readme-essentials/LIFOD.jfif


--------------------------------------------------------------------------------
/readme-essentials/LIFOD.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/noel319/Arduino-Robot/cfe593d5743f8b30175152b90b757df060bbf393/readme-essentials/LIFOD.jpg


--------------------------------------------------------------------------------
/readme-essentials/RAD Doc.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/noel319/Arduino-Robot/cfe593d5743f8b30175152b90b757df060bbf393/readme-essentials/RAD Doc.docx


--------------------------------------------------------------------------------
/readme-essentials/RAD lf.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/noel319/Arduino-Robot/cfe593d5743f8b30175152b90b757df060bbf393/readme-essentials/RAD lf.png


--------------------------------------------------------------------------------
/readme-essentials/RAD oa1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/noel319/Arduino-Robot/cfe593d5743f8b30175152b90b757df060bbf393/readme-essentials/RAD oa1.png


--------------------------------------------------------------------------------
/readme-essentials/RAD oa2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/noel319/Arduino-Robot/cfe593d5743f8b30175152b90b757df060bbf393/readme-essentials/RAD oa2.png


--------------------------------------------------------------------------------
/readme-essentials/~$AD Doc.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/noel319/Arduino-Robot/cfe593d5743f8b30175152b90b757df060bbf393/readme-essentials/~$AD Doc.docx


--------------------------------------------------------------------------------