Color Following Car

Ever wanted a car the drives semi-autonomously? There you have it! You only need two diffrent colored lines and it easy to programm it.

Aug 1, 2018

•

15339 views

•

11 respects

Devices & Components

Arduino Motor Shield Rev3

Breadboard (generic)

Color Sensor

9V battery (generic)

DC motor (generic)

Hardware & Tools

Soldering iron (generic)

Software & Tools

Arduino Web Editor

Arduino IDE

Project description

Code

Copie and Paste Auto Code V17

arduino

Thats the Coe for Copy and Paste. My Change at times.

1#include <AFMotor.h>
2AF_DCMotor motor1(1, MOTOR12_1KHZ);
3AF_DCMotor
4  motor2(3, MOTOR34_1KHZ);
5AF_DCMotor motor3(2, MOTOR12_1KHZ);
6AF_DCMotor motor4(4,
7  MOTOR34_1KHZ);
8//Farbe
9const int s0 = 47; //Conection for Sensor
10const
11  int s1 = 49;
12
13const int s2L = A14;
14const int s3L = A13;
15const int outL
16  = A15;
17
18int redL = 0; //Variablen for Left LEDs named
19int greenL = 0;
20int
21  blueL = 0;
22
23const int s2R = A11;
24const int s3R = A10;
25const int outR
26  = A12;
27
28int redR = 0; //Variablen for Right LEDs named
29int greenR = 0;
30int
31  blueR = 0;
32
33const int s2b = A8;
34const int s3b = A7;
35const int outb =
36  A9;
37
38int redb = 0; //Variablen for Right LEDs named
39int greenb = 0;
40int
41  blueb = 0;
42
43int sensor_left = 0;
44int sensor_right = 0;
45int sensor_back
46  = 0;
47
48void setup()
49
50{
51
52  Serial.begin(9600); //Serielle Kommunikation
53  
54
55  pinMode(s0, OUTPUT);
56  pinMode(s1, OUTPUT);
57  digitalWrite(s0, HIGH);
58
59  digitalWrite(s1, HIGH);
60
61  pinMode(s2L, OUTPUT);
62  pinMode(s3L, OUTPUT);
63
64  pinMode(outL, INPUT);
65
66  pinMode(s2R, OUTPUT);
67  pinMode(s3R, OUTPUT);
68
69  pinMode(outR, INPUT);
70
71  pinMode(s2b, OUTPUT);
72  pinMode(s3b, OUTPUT);
73
74  pinMode(outb, INPUT);
75
76
77
78}
79
80void loop()
81{
82  color();
83
84
85  { //detection
86    { //Sensor Left
87      if (blueL <= 10 && redL >= 11 &&
88  greenL >= 11 && blueL < redL && blueL < greenL)
89
90      {
91        sensor_left
92  = 1;
93      }
94      else
95      {
96        sensor_left = 0;
97      }
98
99    }
100
101    { //Sensor Right
102      if (blueR <= 10 && redR >= 11 && greenR
103  >= 11 && blueR < redR && blueR < greenR)
104
105      {
106        sensor_right
107  = 1;
108      }
109      else
110      {
111        sensor_right = 0;
112      }
113
114    }
115      { //Sensor Back
116      if (blueb <= 10 && redb >= 11 && greenb
117  >= 11 && blueb < redb && blueb < greenb)
118
119      {
120        sensor_back =
121  1;
122      }
123      else
124      {
125        sensor_back = 0;
126      }
127
128    }
129  }
130  { //Drive
131if (sensor_left ==1 or sensor_right==1)
132{
133
134    Found:
135if (sensor_left == 1 && sensor_right == 1 or sensor_left == 1 && sensor_right
136  == 1 && sensor_back == 0)
137    {//Straightforward
138      Straightforward:
139
140      motor1.setSpeed(150);
141      motor2.setSpeed(150);
142      motor3.setSpeed(150);
143
144      motor4.setSpeed(150);
145      motor1.run(FORWARD);
146      motor2.run(FORWARD);
147
148      motor3.run(FORWARD);
149      motor4.run(FORWARD);
150      delay(7);
151
152      motor1.run(RELEASE);
153      motor2.run(RELEASE);
154      motor3.run(RELEASE);
155
156      motor4.run(RELEASE);
157      Serial.print(" Straightforward ");
158    }
159
160    else if (sensor_left == 0 && sensor_right == 1)
161    {//Right Curve
162      motor1.setSpeed(225);
163
164      motor2.setSpeed(225);
165      motor3.setSpeed(200);
166      motor4.setSpeed(200);
167
168      motor1.run(BACKWARD);
169      motor2.run(BACKWARD);
170      motor3.run(FORWARD);
171
172      motor4.run(FORWARD);
173      delay(7);
174      motor1.run(RELEASE);
175
176      motor2.run(RELEASE);
177      motor3.run(RELEASE);
178      motor4.run(RELEASE);
179
180      Serial.print(" Right Curve ");
181    }
182    else if (sensor_left == 1
183  && sensor_right == 0)
184    {//Left Curve
185      motor1.setSpeed(200);
186      motor2.setSpeed(200);
187
188      motor3.setSpeed(225);
189      motor4.setSpeed(225);
190      motor1.run(FORWARD);
191
192      motor2.run(FORWARD);
193      motor3.run(BACKWARD);
194      motor4.run(BACKWARD);
195
196      delay(7);
197      motor1.run(RELEASE);
198      motor2.run(RELEASE);
199
200      motor3.run(RELEASE);
201      motor4.run(RELEASE);
202      Serial.print("
203  Left Curve "); 
204    }
205  } 
206  else if (sensor_left == 0 && sensor_right
207  == 0 && sensor_back == 1)
208  {
209//Backward
210      motor1.setSpeed(160);
211
212      motor2.setSpeed(160);
213      motor3.setSpeed(150);
214      motor4.setSpeed(150);
215
216      motor1.run(BACKWARD);
217      motor2.run(BACKWARD);
218      motor3.run(BACKWARD);
219
220      motor4.run(BACKWARD);
221      delay (7);
222      Serial.print(" Backward
223  "); 
224  }
225  else
226  {
227    
228  }
229  }
230}
231void color() 
232
233{
234
235
236  { //Left Sensor
237    digitalWrite(s2L, LOW);
238    digitalWrite(s3L, LOW);
239
240    redL = pulseIn(outL, digitalRead(outL) == HIGH ? LOW : HIGH);
241    digitalWrite(s3L,
242  HIGH);
243    blueL = pulseIn(outL, digitalRead(outL) == HIGH ? LOW : HIGH);
244
245    digitalWrite(s2L, HIGH);
246    greenL = pulseIn(outL, digitalRead(outL) ==
247  HIGH ? LOW : HIGH);
248  }
249
250  { //Right Sensor
251    digitalWrite(s2R, LOW);
252
253    digitalWrite(s3R, LOW);
254    redR = pulseIn(outR, digitalRead(outR) == HIGH
255  ? LOW : HIGH);
256    digitalWrite(s3R, HIGH);
257    blueR = pulseIn(outR, digitalRead(outR)
258  == HIGH ? LOW : HIGH);
259    digitalWrite(s2R, HIGH);
260    greenR = pulseIn(outR,
261  digitalRead(outR) == HIGH ? LOW : HIGH);
262  }
263    { //Back Sensor
264    digitalWrite(s2b,
265  LOW);
266    digitalWrite(s3b, LOW);
267    redb = pulseIn(outb, digitalRead(outb)
268  == HIGH ? LOW : HIGH);
269    digitalWrite(s3b, HIGH);
270    blueb = pulseIn(outb,
271  digitalRead(outb) == HIGH ? LOW : HIGH);
272    digitalWrite(s2b, HIGH);
273    greenb
274  = pulseIn(outb, digitalRead(outb) == HIGH ? LOW : HIGH);
275  }
276}

#include <AFMotor.h>
AF_DCMotor motor1(1, MOTOR12_1KHZ);
AF_DCMotor
  motor2(3, MOTOR34_1KHZ);
AF_DCMotor motor3(2, MOTOR12_1KHZ);
AF_DCMotor motor4(4,
  MOTOR34_1KHZ);
//Farbe
const int s0 = 47; //Conection for Sensor
const
  int s1 = 49;

const int s2L = A14;
const int s3L = A13;
const int outL
  = A15;

int redL = 0; //Variablen for Left LEDs named
int greenL = 0;
int
  blueL = 0;

const int s2R = A11;
const int s3R = A10;
const int outR
  = A12;

int redR = 0; //Variablen for Right LEDs named
int greenR = 0;
int
  blueR = 0;

const int s2b = A8;
const int s3b = A7;
const int outb =
  A9;

int redb = 0; //Variablen for Right LEDs named
int greenb = 0;
int
  blueb = 0;

int sensor_left = 0;
int sensor_right = 0;
int sensor_back
  = 0;

void setup()

{

  Serial.begin(9600); //Serielle Kommunikation
  

  pinMode(s0, OUTPUT);
  pinMode(s1, OUTPUT);
  digitalWrite(s0, HIGH);

  digitalWrite(s1, HIGH);

  pinMode(s2L, OUTPUT);
  pinMode(s3L, OUTPUT);

  pinMode(outL, INPUT);

  pinMode(s2R, OUTPUT);
  pinMode(s3R, OUTPUT);

  pinMode(outR, INPUT);

  pinMode(s2b, OUTPUT);
  pinMode(s3b, OUTPUT);

  pinMode(outb, INPUT);



}

void loop()
{
  color();


  { //detection
    { //Sensor Left
      if (blueL <= 10 && redL >= 11 &&
  greenL >= 11 && blueL < redL && blueL < greenL)

      {
        sensor_left
  = 1;
      }
      else
      {
        sensor_left = 0;
      }

    }

    { //Sensor Right
      if (blueR <= 10 && redR >= 11 && greenR
  >= 11 && blueR < redR && blueR < greenR)

      {
        sensor_right
  = 1;
      }
      else
      {
        sensor_right = 0;
      }

    }
      { //Sensor Back
      if (blueb <= 10 && redb >= 11 && greenb
  >= 11 && blueb < redb && blueb < greenb)

      {
        sensor_back =
  1;
      }
      else
      {
        sensor_back = 0;
      }

    }
  }
  { //Drive
if (sensor_left ==1 or sensor_right==1)
{

    Found:
if (sensor_left == 1 && sensor_right == 1 or sensor_left == 1 && sensor_right
  == 1 && sensor_back == 0)
    {//Straightforward
      Straightforward:

      motor1.setSpeed(150);
      motor2.setSpeed(150);
      motor3.setSpeed(150);

      motor4.setSpeed(150);
      motor1.run(FORWARD);
      motor2.run(FORWARD);

      motor3.run(FORWARD);
      motor4.run(FORWARD);
      delay(7);

      motor1.run(RELEASE);
      motor2.run(RELEASE);
      motor3.run(RELEASE);

      motor4.run(RELEASE);
      Serial.print(" Straightforward ");
    }

    else if (sensor_left == 0 && sensor_right == 1)
    {//Right Curve
      motor1.setSpeed(225);

      motor2.setSpeed(225);
      motor3.setSpeed(200);
      motor4.setSpeed(200);

      motor1.run(BACKWARD);
      motor2.run(BACKWARD);
      motor3.run(FORWARD);

      motor4.run(FORWARD);
      delay(7);
      motor1.run(RELEASE);

      motor2.run(RELEASE);
      motor3.run(RELEASE);
      motor4.run(RELEASE);

      Serial.print(" Right Curve ");
    }
    else if (sensor_left == 1
  && sensor_right == 0)
    {//Left Curve
      motor1.setSpeed(200);
      motor2.setSpeed(200);

      motor3.setSpeed(225);
      motor4.setSpeed(225);
      motor1.run(FORWARD);

      motor2.run(FORWARD);
      motor3.run(BACKWARD);
      motor4.run(BACKWARD);

      delay(7);
      motor1.run(RELEASE);
      motor2.run(RELEASE);

      motor3.run(RELEASE);
      motor4.run(RELEASE);
      Serial.print("
  Left Curve "); 
    }
  } 
  else if (sensor_left == 0 && sensor_right
  == 0 && sensor_back == 1)
  {
//Backward
      motor1.setSpeed(160);

      motor2.setSpeed(160);
      motor3.setSpeed(150);
      motor4.setSpeed(150);

      motor1.run(BACKWARD);
      motor2.run(BACKWARD);
      motor3.run(BACKWARD);

      motor4.run(BACKWARD);
      delay (7);
      Serial.print(" Backward
  "); 
  }
  else
  {
    
  }
  }
}
void color() 

{


  { //Left Sensor
    digitalWrite(s2L, LOW);
    digitalWrite(s3L, LOW);

    redL = pulseIn(outL, digitalRead(outL) == HIGH ? LOW : HIGH);
    digitalWrite(s3L,
  HIGH);
    blueL = pulseIn(outL, digitalRead(outL) == HIGH ? LOW : HIGH);

    digitalWrite(s2L, HIGH);
    greenL = pulseIn(outL, digitalRead(outL) ==
  HIGH ? LOW : HIGH);
  }

  { //Right Sensor
    digitalWrite(s2R, LOW);

    digitalWrite(s3R, LOW);
    redR = pulseIn(outR, digitalRead(outR) == HIGH
  ? LOW : HIGH);
    digitalWrite(s3R, HIGH);
    blueR = pulseIn(outR, digitalRead(outR)
  == HIGH ? LOW : HIGH);
    digitalWrite(s2R, HIGH);
    greenR = pulseIn(outR,
  digitalRead(outR) == HIGH ? LOW : HIGH);
  }
    { //Back Sensor
    digitalWrite(s2b,
  LOW);
    digitalWrite(s3b, LOW);
    redb = pulseIn(outb, digitalRead(outb)
  == HIGH ? LOW : HIGH);
    digitalWrite(s3b, HIGH);
    blueb = pulseIn(outb,
  digitalRead(outb) == HIGH ? LOW : HIGH);
    digitalWrite(s2b, HIGH);
    greenb
  = pulseIn(outb, digitalRead(outb) == HIGH ? LOW : HIGH);
  }
}

Copie and Paste Auto Code V17

arduino

Thats the Coe for Copy and Paste. My Change at times.

1#include <AFMotor.h>
2AF_DCMotor motor1(1, MOTOR12_1KHZ);
3AF_DCMotor  motor2(3, MOTOR34_1KHZ);
4AF_DCMotor motor3(2, MOTOR12_1KHZ);
5AF_DCMotor motor4(4,  MOTOR34_1KHZ);
6//Farbe
7const int s0 = 47; //Conection for Sensor
8const  int s1 = 49;
9
10const int s2L = A14;
11const int s3L = A13;
12const int outL  = A15;
13
14int redL = 0; //Variablen for Left LEDs named
15int greenL = 0;
16int  blueL = 0;
17
18const int s2R = A11;
19const int s3R = A10;
20const int outR  = A12;
21
22int redR = 0; //Variablen for Right LEDs named
23int greenR = 0;
24int  blueR = 0;
25
26const int s2b = A8;
27const int s3b = A7;
28const int outb =  A9;
29
30int redb = 0; //Variablen for Right LEDs named
31int greenb = 0;
32int  blueb = 0;
33
34int sensor_left = 0;
35int sensor_right = 0;
36int sensor_back  = 0;
37
38void setup()
39
40{
41
42  Serial.begin(9600); //Serielle Kommunikation  
43
44  pinMode(s0, OUTPUT);
45  pinMode(s1, OUTPUT);
46  digitalWrite(s0, HIGH);
47  digitalWrite(s1, HIGH);
48
49  pinMode(s2L, OUTPUT);
50  pinMode(s3L, OUTPUT);
51  pinMode(outL, INPUT);
52
53  pinMode(s2R, OUTPUT);
54  pinMode(s3R, OUTPUT);
55  pinMode(outR, INPUT);
56
57  pinMode(s2b, OUTPUT);
58  pinMode(s3b, OUTPUT);
59  pinMode(outb, INPUT);
60
61
62
63}
64
65void loop()
66{
67  color();
68
69  { //detection
70    { //Sensor Left
71      if (blueL <= 10 && redL >= 11 &&  greenL >= 11 && blueL < redL && blueL < greenL)
72
73      {
74        sensor_left  = 1;
75      }
76      else
77      {
78        sensor_left = 0;
79      }
80    }
81
82    { //Sensor Right
83      if (blueR <= 10 && redR >= 11 && greenR  >= 11 && blueR < redR && blueR < greenR)
84
85      {
86        sensor_right  = 1;
87      }
88      else
89      {
90        sensor_right = 0;
91      }
92    }
93      { //Sensor Back
94      if (blueb <= 10 && redb >= 11 && greenb  >= 11 && blueb < redb && blueb < greenb)
95
96      {
97        sensor_back =  1;
98      }
99      else
100      {
101        sensor_back = 0;
102      }
103    }
104  }
105  { //Drive
106if (sensor_left ==1 or sensor_right==1)
107{
108    Found:
109if (sensor_left == 1 && sensor_right == 1 or sensor_left == 1 && sensor_right  == 1 && sensor_back == 0)
110    {//Straightforward
111      Straightforward:
112      motor1.setSpeed(150);
113      motor2.setSpeed(150);
114      motor3.setSpeed(150);
115      motor4.setSpeed(150);
116      motor1.run(FORWARD);
117      motor2.run(FORWARD);
118      motor3.run(FORWARD);
119      motor4.run(FORWARD);
120      delay(7);
121      motor1.run(RELEASE);
122      motor2.run(RELEASE);
123      motor3.run(RELEASE);
124      motor4.run(RELEASE);
125      Serial.print(" Straightforward ");
126    }
127    else if (sensor_left == 0 && sensor_right == 1)
128    {//Right Curve
129      motor1.setSpeed(225);
130      motor2.setSpeed(225);
131      motor3.setSpeed(200);
132      motor4.setSpeed(200);
133      motor1.run(BACKWARD);
134      motor2.run(BACKWARD);
135      motor3.run(FORWARD);
136      motor4.run(FORWARD);
137      delay(7);
138      motor1.run(RELEASE);
139      motor2.run(RELEASE);
140      motor3.run(RELEASE);
141      motor4.run(RELEASE);
142      Serial.print(" Right Curve ");
143    }
144    else if (sensor_left == 1  && sensor_right == 0)
145    {//Left Curve
146      motor1.setSpeed(200);
147      motor2.setSpeed(200);
148      motor3.setSpeed(225);
149      motor4.setSpeed(225);
150      motor1.run(FORWARD);
151      motor2.run(FORWARD);
152      motor3.run(BACKWARD);
153      motor4.run(BACKWARD);
154      delay(7);
155      motor1.run(RELEASE);
156      motor2.run(RELEASE);
157      motor3.run(RELEASE);
158      motor4.run(RELEASE);
159      Serial.print("  Left Curve "); 
160    }
161  } 
162  else if (sensor_left == 0 && sensor_right  == 0 && sensor_back == 1)
163  {
164//Backward
165      motor1.setSpeed(160);
166      motor2.setSpeed(160);
167      motor3.setSpeed(150);
168      motor4.setSpeed(150);
169      motor1.run(BACKWARD);
170      motor2.run(BACKWARD);
171      motor3.run(BACKWARD);
172      motor4.run(BACKWARD);
173      delay (7);
174      Serial.print(" Backward  "); 
175  }
176  else
177  {
178    
179  }
180  }
181}
182void color() 
183
184{
185
186  { //Left Sensor
187    digitalWrite(s2L, LOW);
188    digitalWrite(s3L, LOW);
189    redL = pulseIn(outL, digitalRead(outL) == HIGH ? LOW : HIGH);
190    digitalWrite(s3L,  HIGH);
191    blueL = pulseIn(outL, digitalRead(outL) == HIGH ? LOW : HIGH);
192    digitalWrite(s2L, HIGH);
193    greenL = pulseIn(outL, digitalRead(outL) ==  HIGH ? LOW : HIGH);
194  }
195
196  { //Right Sensor
197    digitalWrite(s2R, LOW);
198    digitalWrite(s3R, LOW);
199    redR = pulseIn(outR, digitalRead(outR) == HIGH  ? LOW : HIGH);
200    digitalWrite(s3R, HIGH);
201    blueR = pulseIn(outR, digitalRead(outR)  == HIGH ? LOW : HIGH);
202    digitalWrite(s2R, HIGH);
203    greenR = pulseIn(outR,  digitalRead(outR) == HIGH ? LOW : HIGH);
204  }
205    { //Back Sensor
206    digitalWrite(s2b,  LOW);
207    digitalWrite(s3b, LOW);
208    redb = pulseIn(outb, digitalRead(outb)  == HIGH ? LOW : HIGH);
209    digitalWrite(s3b, HIGH);
210    blueb = pulseIn(outb,  digitalRead(outb) == HIGH ? LOW : HIGH);
211    digitalWrite(s2b, HIGH);
212    greenb  = pulseIn(outb, digitalRead(outb) == HIGH ? LOW : HIGH);
213  }
214}

#include <AFMotor.h>
AF_DCMotor motor1(1, MOTOR12_1KHZ);
AF_DCMotor  motor2(3, MOTOR34_1KHZ);
AF_DCMotor motor3(2, MOTOR12_1KHZ);
AF_DCMotor motor4(4,  MOTOR34_1KHZ);
//Farbe
const int s0 = 47; //Conection for Sensor
const  int s1 = 49;

const int s2L = A14;
const int s3L = A13;
const int outL  = A15;

int redL = 0; //Variablen for Left LEDs named
int greenL = 0;
int  blueL = 0;

const int s2R = A11;
const int s3R = A10;
const int outR  = A12;

int redR = 0; //Variablen for Right LEDs named
int greenR = 0;
int  blueR = 0;

const int s2b = A8;
const int s3b = A7;
const int outb =  A9;

int redb = 0; //Variablen for Right LEDs named
int greenb = 0;
int  blueb = 0;

int sensor_left = 0;
int sensor_right = 0;
int sensor_back  = 0;

void setup()

{

  Serial.begin(9600); //Serielle Kommunikation  

  pinMode(s0, OUTPUT);
  pinMode(s1, OUTPUT);
  digitalWrite(s0, HIGH);
  digitalWrite(s1, HIGH);

  pinMode(s2L, OUTPUT);
  pinMode(s3L, OUTPUT);
  pinMode(outL, INPUT);

  pinMode(s2R, OUTPUT);
  pinMode(s3R, OUTPUT);
  pinMode(outR, INPUT);

  pinMode(s2b, OUTPUT);
  pinMode(s3b, OUTPUT);
  pinMode(outb, INPUT);



}

void loop()
{
  color();

  { //detection
    { //Sensor Left
      if (blueL <= 10 && redL >= 11 &&  greenL >= 11 && blueL < redL && blueL < greenL)

      {
        sensor_left  = 1;
      }
      else
      {
        sensor_left = 0;
      }
    }

    { //Sensor Right
      if (blueR <= 10 && redR >= 11 && greenR  >= 11 && blueR < redR && blueR < greenR)

      {
        sensor_right  = 1;
      }
      else
      {
        sensor_right = 0;
      }
    }
      { //Sensor Back
      if (blueb <= 10 && redb >= 11 && greenb  >= 11 && blueb < redb && blueb < greenb)

      {
        sensor_back =  1;
      }
      else
      {
        sensor_back = 0;
      }
    }
  }
  { //Drive
if (sensor_left ==1 or sensor_right==1)
{
    Found:
if (sensor_left == 1 && sensor_right == 1 or sensor_left == 1 && sensor_right  == 1 && sensor_back == 0)
    {//Straightforward
      Straightforward:
      motor1.setSpeed(150);
      motor2.setSpeed(150);
      motor3.setSpeed(150);
      motor4.setSpeed(150);
      motor1.run(FORWARD);
      motor2.run(FORWARD);
      motor3.run(FORWARD);
      motor4.run(FORWARD);
      delay(7);
      motor1.run(RELEASE);
      motor2.run(RELEASE);
      motor3.run(RELEASE);
      motor4.run(RELEASE);
      Serial.print(" Straightforward ");
    }
    else if (sensor_left == 0 && sensor_right == 1)
    {//Right Curve
      motor1.setSpeed(225);
      motor2.setSpeed(225);
      motor3.setSpeed(200);
      motor4.setSpeed(200);
      motor1.run(BACKWARD);
      motor2.run(BACKWARD);
      motor3.run(FORWARD);
      motor4.run(FORWARD);
      delay(7);
      motor1.run(RELEASE);
      motor2.run(RELEASE);
      motor3.run(RELEASE);
      motor4.run(RELEASE);
      Serial.print(" Right Curve ");
    }
    else if (sensor_left == 1  && sensor_right == 0)
    {//Left Curve
      motor1.setSpeed(200);
      motor2.setSpeed(200);
      motor3.setSpeed(225);
      motor4.setSpeed(225);
      motor1.run(FORWARD);
      motor2.run(FORWARD);
      motor3.run(BACKWARD);
      motor4.run(BACKWARD);
      delay(7);
      motor1.run(RELEASE);
      motor2.run(RELEASE);
      motor3.run(RELEASE);
      motor4.run(RELEASE);
      Serial.print("  Left Curve "); 
    }
  } 
  else if (sensor_left == 0 && sensor_right  == 0 && sensor_back == 1)
  {
//Backward
      motor1.setSpeed(160);
      motor2.setSpeed(160);
      motor3.setSpeed(150);
      motor4.setSpeed(150);
      motor1.run(BACKWARD);
      motor2.run(BACKWARD);
      motor3.run(BACKWARD);
      motor4.run(BACKWARD);
      delay (7);
      Serial.print(" Backward  "); 
  }
  else
  {
    
  }
  }
}
void color() 

{

  { //Left Sensor
    digitalWrite(s2L, LOW);
    digitalWrite(s3L, LOW);
    redL = pulseIn(outL, digitalRead(outL) == HIGH ? LOW : HIGH);
    digitalWrite(s3L,  HIGH);
    blueL = pulseIn(outL, digitalRead(outL) == HIGH ? LOW : HIGH);
    digitalWrite(s2L, HIGH);
    greenL = pulseIn(outL, digitalRead(outL) ==  HIGH ? LOW : HIGH);
  }

  { //Right Sensor
    digitalWrite(s2R, LOW);
    digitalWrite(s3R, LOW);
    redR = pulseIn(outR, digitalRead(outR) == HIGH  ? LOW : HIGH);
    digitalWrite(s3R, HIGH);
    blueR = pulseIn(outR, digitalRead(outR)  == HIGH ? LOW : HIGH);
    digitalWrite(s2R, HIGH);
    greenR = pulseIn(outR,  digitalRead(outR) == HIGH ? LOW : HIGH);
  }
    { //Back Sensor
    digitalWrite(s2b,  LOW);
    digitalWrite(s3b, LOW);
    redb = pulseIn(outb, digitalRead(outb)  == HIGH ? LOW : HIGH);
    digitalWrite(s3b, HIGH);
    blueb = pulseIn(outb,  digitalRead(outb) == HIGH ? LOW : HIGH);
    digitalWrite(s2b, HIGH);
    greenb  = pulseIn(outb, digitalRead(outb) == HIGH ? LOW : HIGH);
  }
}

Downloadable files

Schema

Schema in a Fritzing format

Schema

Schema in a JPG

Schema

Schema in a Fritzing format

Schema

Comments

Only logged in users can leave comments

Maxconnor

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content