Flashlight Controlled Solar Powered Robot Using Arduino

1constintfrontPin = A0;
2constintleftPin = A1;
3constintrightPin =
4  A2;
5constintbackPin = A3;
6constintleftMotor = 9;
7constintrightMotor = 10;
8intthreshHold
9  = 170;
10int Direction;
11int direction1;
12int direction2;
13int Delay = 25;
14int
15  Delay2 = 25;
16
17void setup()
18{
19
20pinMode(frontPin, INPUT);
21pinMode(leftPin,
22  INPUT);
23pinMode(rightPin, INPUT);
24pinMode(backPin, INPUT);
25pinMode(leftMotor,
26  OUTPUT);
27pinMode(rightMotor, OUTPUT);
28digitalWrite(leftMotor, HIGH);
29digitalWrite(rightMotor,HIGH);
30delay(100);
31digitalWrite(leftMotor,
32  LOW);
33digitalWrite(rightMotor, LOW);
34delay(100);
35digitalWrite(leftMotor,
36  HIGH);
37digitalWrite(rightMotor, HIGH);
38delay(100);
39digitalWrite(leftMotor,
40  LOW);
41digitalWrite(rightMotor, LOW);
42delay(1500);
43Serial.begin(9600);  
44}
45
46void
47  loop()
48{
49
50int Direction;
51int direction1;
52int direction2;
53intfrontSignal
54  = 1023 - analogRead(frontPin);
55intleftSignal = 1023 - analogRead(leftPin);
56intrightSignal
57  = 1023 - analogRead(rightPin);
58intbackSignal = 1023 - analogRead(backPin);
59Serial.println(frontSignal);
60  
61Serial.println(leftSignal); 
62Serial.println(rightSignal); 
63Serial.println(backSignal);
64//
65  frontSignal + leftSignal + rightSignal + backSignal<= threshHold
66if (abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)
67  >= threshHold )
68{
69Serial.println("motion loop");
70                     direction1
71  = max(frontSignal, leftSignal);
72                     direction2 = max(rightSignal,
73  backSignal);
74                      Direction = max(direction1, direction2);
75//Loop
76  here is entered only if the light received is not evenly distributed.
77     if
78  (frontSignal == Direction)
79     {
80                   do
81                   {
82
83                         digitalWrite(leftMotor, HIGH);
84                         digitalWrite(rightMotor,
85  HIGH);
86                         delay(Delay2);
87                         digitalWrite(leftMotor,
88  LOW);
89                         digitalWrite(rightMotor, LOW);
90                         delay(Delay);
91
92                         frontSignal = 1023 - analogRead(frontPin);
93                         leftSignal
94  = 1023 - analogRead(leftPin);
95                         rightSignal = 1023 - analogRead(rightPin);
96
97                         backSignal = 1023 - analogRead(backPin);
98                         direction1
99  = max(frontSignal, leftSignal);
100                         direction2 = max(rightSignal,
101  backSignal);
102                         Direction = max(direction1, direction2);
103
104                         Serial.println("Forward");
105          
106                   }
107  while(frontSignal == Direction && abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)
108  >= threshHold);
109           digitalWrite(leftMotor, LOW);
110           digitalWrite(rightMotor,
111  LOW); 
112     }
113     else if (leftSignal == Direction)     //Signal is greatest
114  on the left
115     {
116                             do
117                 {
118
119                       Serial.println("Left");
120                       digitalWrite(rightMotor,
121  HIGH);
122                       delay(Delay2);
123                       digitalWrite(rightMotor,
124  LOW);
125                       delay(Delay);
126                       frontSignal
127  = 1023 - analogRead(frontPin);
128                       leftSignal = 1023 - analogRead(leftPin);
129
130                       rightSignal = 1023 - analogRead(rightPin);
131                       backSignal
132  = 1023 - analogRead(backPin);
133                       direction1 = max(frontSignal,
134  leftSignal);
135                       direction2 = max(rightSignal, backSignal);
136
137                       Direction = max(direction1, direction2);
138                 }
139  while(leftSignal == Direction && abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)
140  >= threshHold);
141          digitalWrite(rightMotor, LOW);
142     }
143     else
144  if (rightSignal == Direction)        //Signal is greatest on the right.
145     {
146
147               do
148               {
149                     Serial.println("Right");
150
151                     digitalWrite(leftMotor, HIGH);
152                     delay(Delay2);
153
154                     digitalWrite(leftMotor, LOW);
155                     delay(Delay);
156             
157                     frontSignal = 1023 - analogRead(frontPin);
158
159                     leftSignal = 1023 - analogRead(leftPin);
160                     rightSignal
161  = 1023 - analogRead(rightPin);
162                     backSignal = 1023 - analogRead(backPin);
163
164                     direction1 = max(frontSignal, leftSignal);
165                     direction2
166  = max(rightSignal, backSignal);
167                     Direction = max(direction1,
168  direction2);
169                    
170               } while(rightSignal == Direction
171  && abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)
172  >= threshHold);
173               digitalWrite(leftMotor, LOW);
174     }
175     else
176  if (backSignal == Direction)      //Signal is greatest behind.
177     {
178               do
179
180               {
181                     Serial.println("Back");
182                     digitalWrite(leftMotor,
183  HIGH);
184                     delay(Delay2);
185                     digitalWrite(leftMotor,
186  LOW);
187                     delay(Delay);             
188                     frontSignal
189  = 1023 - analogRead(frontPin);
190                     leftSignal = 1023 - analogRead(leftPin);
191
192                     rightSignal = 1023 - analogRead(rightPin);
193                     backSignal
194  = 1023 - analogRead(backPin);
195                     direction1 = max(frontSignal,
196  leftSignal);
197                     direction2 = max(rightSignal, backSignal);
198
199                     Direction = max(direction1, direction2);
200               }
201  while(backSignal == Direction && abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)
202  >= threshHold);
203               digitalWrite(leftMotor, LOW);
204     }
205}
206else
207  if(abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)
208  <= threshHold)
209{
210             int difference = abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal);
211
212             Serial.println("Signal differential is equal to ");
213             Serial.println(difference);
214
215             digitalWrite(leftMotor, LOW);
216             digitalWrite(rightMotor,
217  LOW);
218             delay(1000); // Else sample environment at a rate of 10 hz
219}
220else
221{
222
223             digitalWrite(leftMotor, LOW);
224             digitalWrite(rightMotor,
225  LOW);
226}
227
228} 
229

1constintfrontPin = A0;
2constintleftPin = A1;
3constintrightPin =  A2;
4constintbackPin = A3;
5constintleftMotor = 9;
6constintrightMotor = 10;
7intthreshHold  = 170;
8int Direction;
9int direction1;
10int direction2;
11int Delay = 25;
12int  Delay2 = 25;
13
14void setup()
15{
16
17pinMode(frontPin, INPUT);
18pinMode(leftPin,  INPUT);
19pinMode(rightPin, INPUT);
20pinMode(backPin, INPUT);
21pinMode(leftMotor,  OUTPUT);
22pinMode(rightMotor, OUTPUT);
23digitalWrite(leftMotor, HIGH);
24digitalWrite(rightMotor,HIGH);
25delay(100);
26digitalWrite(leftMotor,  LOW);
27digitalWrite(rightMotor, LOW);
28delay(100);
29digitalWrite(leftMotor,  HIGH);
30digitalWrite(rightMotor, HIGH);
31delay(100);
32digitalWrite(leftMotor,  LOW);
33digitalWrite(rightMotor, LOW);
34delay(1500);
35Serial.begin(9600);  
36}
37
38void  loop()
39{
40
41int Direction;
42int direction1;
43int direction2;
44intfrontSignal  = 1023 - analogRead(frontPin);
45intleftSignal = 1023 - analogRead(leftPin);
46intrightSignal  = 1023 - analogRead(rightPin);
47intbackSignal = 1023 - analogRead(backPin);
48Serial.println(frontSignal);  
49Serial.println(leftSignal); 
50Serial.println(rightSignal); 
51Serial.println(backSignal);
52//  frontSignal + leftSignal + rightSignal + backSignal<= threshHold
53if (abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)  >= threshHold )
54{
55Serial.println("motion loop");
56                     direction1  = max(frontSignal, leftSignal);
57                     direction2 = max(rightSignal,  backSignal);
58                      Direction = max(direction1, direction2);
59//Loop  here is entered only if the light received is not evenly distributed.
60     if  (frontSignal == Direction)
61     {
62                   do
63                   {
64                         digitalWrite(leftMotor, HIGH);
65                         digitalWrite(rightMotor,  HIGH);
66                         delay(Delay2);
67                         digitalWrite(leftMotor,  LOW);
68                         digitalWrite(rightMotor, LOW);
69                         delay(Delay);
70                         frontSignal = 1023 - analogRead(frontPin);
71                         leftSignal  = 1023 - analogRead(leftPin);
72                         rightSignal = 1023 - analogRead(rightPin);
73                         backSignal = 1023 - analogRead(backPin);
74                         direction1  = max(frontSignal, leftSignal);
75                         direction2 = max(rightSignal,  backSignal);
76                         Direction = max(direction1, direction2);
77                         Serial.println("Forward");
78          
79                   }  while(frontSignal == Direction && abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)  >= threshHold);
80           digitalWrite(leftMotor, LOW);
81           digitalWrite(rightMotor,  LOW); 
82     }
83     else if (leftSignal == Direction)     //Signal is greatest  on the left
84     {
85                             do
86                 {
87                       Serial.println("Left");
88                       digitalWrite(rightMotor,  HIGH);
89                       delay(Delay2);
90                       digitalWrite(rightMotor,  LOW);
91                       delay(Delay);
92                       frontSignal  = 1023 - analogRead(frontPin);
93                       leftSignal = 1023 - analogRead(leftPin);
94                       rightSignal = 1023 - analogRead(rightPin);
95                       backSignal  = 1023 - analogRead(backPin);
96                       direction1 = max(frontSignal,  leftSignal);
97                       direction2 = max(rightSignal, backSignal);
98                       Direction = max(direction1, direction2);
99                 }  while(leftSignal == Direction && abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)  >= threshHold);
100          digitalWrite(rightMotor, LOW);
101     }
102     else  if (rightSignal == Direction)        //Signal is greatest on the right.
103     {
104               do
105               {
106                     Serial.println("Right");
107                     digitalWrite(leftMotor, HIGH);
108                     delay(Delay2);
109                     digitalWrite(leftMotor, LOW);
110                     delay(Delay);             
111                     frontSignal = 1023 - analogRead(frontPin);
112                     leftSignal = 1023 - analogRead(leftPin);
113                     rightSignal  = 1023 - analogRead(rightPin);
114                     backSignal = 1023 - analogRead(backPin);
115                     direction1 = max(frontSignal, leftSignal);
116                     direction2  = max(rightSignal, backSignal);
117                     Direction = max(direction1,  direction2);
118                    
119               } while(rightSignal == Direction  && abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)  >= threshHold);
120               digitalWrite(leftMotor, LOW);
121     }
122     else  if (backSignal == Direction)      //Signal is greatest behind.
123     {
124               do
125               {
126                     Serial.println("Back");
127                     digitalWrite(leftMotor,  HIGH);
128                     delay(Delay2);
129                     digitalWrite(leftMotor,  LOW);
130                     delay(Delay);             
131                     frontSignal  = 1023 - analogRead(frontPin);
132                     leftSignal = 1023 - analogRead(leftPin);
133                     rightSignal = 1023 - analogRead(rightPin);
134                     backSignal  = 1023 - analogRead(backPin);
135                     direction1 = max(frontSignal,  leftSignal);
136                     direction2 = max(rightSignal, backSignal);
137                     Direction = max(direction1, direction2);
138               }  while(backSignal == Direction && abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)  >= threshHold);
139               digitalWrite(leftMotor, LOW);
140     }
141}
142else  if(abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal)  <= threshHold)
143{
144             int difference = abs(frontSignal-leftSignal)+abs(frontSignal-rightSignal)+abs(frontSignal-backSignal);
145             Serial.println("Signal differential is equal to ");
146             Serial.println(difference);
147             digitalWrite(leftMotor, LOW);
148             digitalWrite(rightMotor,  LOW);
149             delay(1000); // Else sample environment at a rate of 10 hz
150}
151else
152{
153             digitalWrite(leftMotor, LOW);
154             digitalWrite(rightMotor,  LOW);
155}
156
157} 
158