Fire-Fighting Robot with Remote Control + Video transmitting

1/*
2  Fire-Fighting Robot and Remote Control with Camera
3
4  THIS CODE FOR ARDUIONO NANO in REMOTE
5
6  This code controls a fire-fighting robot equipped with a remote controller using nRF24L01 for wireless communication.
7   The robot features servos for camera and nozzle movement, motors for mobility, and sensors for fire detection. 
8   It includes LEDs for status indication and a water pump system to extinguish flames. 
9   The robot can move forward, backward, and turn, all controlled remotely, while the water pump activates when fire is detected.
10
11  Authors : Pipisara Chandrabhanu
12          : Oshan Kavinda
13          : Amindu Prabshwara
14*/
15
16
17#include <SPI.h>       // Include SPI library
18#include <nRF24L01.h>  // Include nRF24L01 library
19#include <RF24.h>      // Include RF24 library
20
21RF24 radio(9, 10);                // Define RF24 object with CE, CSN pins
22const byte address[6] = "00001";  // Address for the communication channel
23
24#define FSwitch 6  // directions switches
25#define BSwitch 7
26#define RSwitch 5
27#define LSwitch 4
28
29#define Lservosw 0  //  servo switches
30#define Rservosw 1
31
32#define CamLservosw A4 //  servo switches
33#define CamRservosw A5
34
35#define Flash A1
36
37#define pumpsw 8  //  for pump switch
38
39#define LED A2   //  for LED
40
41
42void setup() {
43  radio.begin();                      // Initialize radio
44  radio.openWritingPipe(address);     // Open writing pipe
45  radio.openReadingPipe(1, address);  // Open reading pipe
46  radio.setPALevel(RF24_PA_LOW);      // Set power level
47
48  // Set pin modes
49  pinMode(FSwitch, INPUT_PULLUP);
50  pinMode(BSwitch, INPUT_PULLUP);
51  pinMode(LSwitch, INPUT_PULLUP);
52  pinMode(RSwitch, INPUT_PULLUP);
53  pinMode(Lservosw, INPUT_PULLUP);
54  pinMode(Rservosw, INPUT_PULLUP);
55  pinMode(pumpsw, INPUT_PULLUP);
56  pinMode(CamLservosw, INPUT_PULLUP);
57  pinMode(CamRservosw, INPUT_PULLUP);
58  pinMode(Flash, INPUT_PULLUP);
59
60
61  Serial.begin(9600);  // Initialize serial communication
62}
63
64void loop() {
65  // Read state of switches
66  int Forward = !digitalRead(FSwitch);
67  int Backward = !digitalRead(BSwitch);
68  int Left = !digitalRead(LSwitch);
69  int Right = !digitalRead(RSwitch);
70  int LServo = !digitalRead(Lservosw);
71  int Rservo = !digitalRead(Rservosw);
72  int pump = !digitalRead(pumpsw);
73  int camL = !digitalRead(CamLservosw);
74  int camR = !digitalRead(CamRservosw);
75  int Flasher = !digitalRead(Flash);
76  // Count how many switches are pressed
77  int buttonCount = Forward + Backward + Left + Right + LServo + Rservo + pump + camL + camR + Flasher;
78
79  // Check if both servo switches are pressed
80  if (LServo == HIGH && Rservo == HIGH) {
81    char dataToSend = 'Y';
82    analogWrite(LED, 255);
83    radio.write(&dataToSend, sizeof(dataToSend));
84    return;  //
85  }
86  if (camL == HIGH && camR == HIGH) {
87    char dataToSend = 'K';
88    analogWrite(LED, 255);
89    radio.write(&dataToSend, sizeof(dataToSend));
90    return;  //
91  }
92  
93  // Check if more than one switch is pressed
94  else if (buttonCount >= 2) {
95    char dataToSend = 'S';
96    analogWrite(LED, 0);
97    radio.write(&dataToSend, sizeof(dataToSend));
98    delay(100);  // Delay for stability
99    return;
100  }
101
102  // Check which direction switch is pressed and send corresponding signal
103  if (Forward == HIGH) {
104    char dataToSend = 'F';  // move forward
105    analogWrite(LED, 255);
106    radio.write(&dataToSend, sizeof(dataToSend));
107    
108  } 
109  else if (camL == HIGH) {
110    char dataToSend = 'M';  // cam servo turn
111    analogWrite(LED, 255);
112    radio.write(&dataToSend, sizeof(dataToSend));
113  } else if (camR == HIGH) {
114    char dataToSend = 'N';  // cam servo turn
115    analogWrite(LED, 255);
116    radio.write(&dataToSend, sizeof(dataToSend));
117  }
118  else if (Backward == HIGH) {
119    char dataToSend = 'B';  // move backward
120    analogWrite(LED, 255);
121    radio.write(&dataToSend, sizeof(dataToSend));
122  } else if (Left == HIGH) {
123    char dataToSend = 'L';  // turn left
124    analogWrite(LED, 255);
125    radio.write(&dataToSend, sizeof(dataToSend));
126  } else if (Right == HIGH) {
127    char dataToSend = 'R';  // turn right
128    analogWrite(LED, 255);
129    radio.write(&dataToSend, sizeof(dataToSend));
130  } else if (LServo == HIGH) {
131    char dataToSend = 'A';  // move left servo
132    analogWrite(LED, 255);
133    radio.write(&dataToSend, sizeof(dataToSend));
134  } else if (Rservo == HIGH) {
135    char dataToSend = 'D';  // move right servo
136    analogWrite(LED, 255);
137    radio.write(&dataToSend, sizeof(dataToSend));
138  } 
139  else if (Flasher == HIGH) {
140    char dataToSend = 'Z';  // move right servo
141    delay(500);
142    analogWrite(LED, 255);
143    radio.write(&dataToSend, sizeof(dataToSend));
144  } 
145  
146  else if (pump == HIGH) {
147    char dataToSend = 'W';  // operate pump
148    delay(500);             // Delay for stability
149    analogWrite(LED, 255);
150    radio.write(&dataToSend, sizeof(dataToSend));
151  } else if (Right == LOW && Right == LOW && Right == LOW && Right == LOW) {
152    char dataToSend = 'S';
153    analogWrite(LED, 0);
154    radio.write(&dataToSend, sizeof(dataToSend));
155  } else {
156    char dataToSend = 'S';
157    analogWrite(LED, 0);
158    radio.write(&dataToSend, sizeof(dataToSend));
159  }
160  
161}

1/*
2 Fire-Fighting Robot and Remote Control with Camera       
3
4  THIS CODE FOR ARDUIONO MEGA ROBOT
5
6  This code controls a fire-fighting robot equipped with a remote controller using nRF24L01 for wireless communication.
7   The robot features servos for camera and nozzle movement, motors for mobility, and sensors for fire detection. 
8   It includes LEDs for status indication and a water pump system to extinguish flames. 
9   The robot can move forward, backward, and turn, all controlled remotely, while the water pump activates when fire is detected.
10
11  Authors : Pipisara Chandrabhanu
12          : Oshan Kavinda
13          : Amindu Prabshwara
14*/
15
16
17#include <SPI.h> // Include SPI library
18#include <nRF24L01.h> // Include nRF24L01 library
19#include <RF24.h> // Include RF24 library
20#include <Servo.h> // Include Servo  Library
21
22Servo TopServo;
23
24Servo CamServo;
25
26RF24 radio(2, 3);                
27const byte address[6] = "00001";  // Address for the communication channel
28
29
30#define LFM 9    // Left forward Motor
31#define LBM 8    // Left backward Motor
32#define RFM 11   // Right forward Motor
33#define RBM 10   // Right backward Motor
34#define LPWM 12  // Left PWM
35#define RPWM 13  // Right PWM
36
37
38#define LeftLED 22
39#define RightLED 23
40#define ReverseLED 24
41#define FlameLed 25 // flame detect led
42#define PumpLED 26  // pumpled
43#define SLED 27   // Left Top_Servo
44#define RSLED 28  // Right Top_Servo
45#define WPLED 29  // Water pump
46#define SignalLED 30
47
48#define Flasher 40
49
50
51
52#define Top_Servo 5
53#define Cam_Servo 6
54
55
56#define WPump 7        // Water pump pin
57#define FlameSensor 42  // IR sensor pin
58#define FlameSensor2 43 //second ir
59
60int angle = 90;     // Top_Servo angle
61int Camangle = 90;
62
63int pumpstate = 0 ;  // Water pump state
64
65int flasState = 0;  //flasher for cam
66
67unsigned long currentTime;  // to blink light
68unsigned long previousTime = 0;
69const long interval = 200;
70int ledStateblink = LOW;
71int reset = 0;
72
73
74void setup() {
75
76
77  radio.begin();
78  radio.openReadingPipe(1, address);
79  radio.setPALevel(RF24_PA_LOW);
80  radio.startListening();
81
82
83  TopServo.attach(Top_Servo);
84  TopServo.write(90);
85
86  CamServo.attach(Cam_Servo);
87  CamServo.write(90);
88
89  for (int x = 22; x < 41; x++) {  // LED OUTPUT
90
91    pinMode(x, OUTPUT);
92  }
93
94
95
96  pinMode(LFM, OUTPUT);
97  pinMode(LBM, OUTPUT);
98  pinMode(RFM, OUTPUT);
99  pinMode(RBM, OUTPUT);
100  pinMode(LPWM, OUTPUT);
101  pinMode(RPWM, OUTPUT);
102  pinMode(WPump, OUTPUT);
103  pinMode(FlameSensor, INPUT);
104  pinMode(FlameSensor2, INPUT);
105
106  TopServo.write(angle);
107  analogWrite(LPWM, 155);
108  analogWrite(RPWM, 155);
109  digitalWrite(WPump, HIGH);
110  digitalWrite(Flasher, HIGH);
111
112  Serial.begin(9600); // Initialize serial communication
113  SPI.begin(); // Initialize SPI communication
114 
115}
116
117
118
119void loop() {
120
121
122
123
124 if (reset == 0) {
125    if (digitalRead(FlameSensor) == 0) {
126      digitalWrite(FlameLed, HIGH);
127    
128
129      if (pumpstate == 0) {
130        digitalWrite(WPump, LOW);
131        digitalWrite(PumpLED, HIGH);
132        Camangle=135;
133        TopServo.write(Camangle);
134        reset = 1;
135      }
136    }
137    
138    if (digitalRead(FlameSensor2) == 0) {
139      digitalWrite(FlameLed, HIGH);
140    
141 
142      if (pumpstate == 0) {
143        digitalWrite(WPump, LOW);
144        digitalWrite(PumpLED, HIGH);
145        Camangle=45;
146        TopServo.write(Camangle);
147        reset = 1;
148      }
149    }
150    
151  }
152
153
154   if (radio.available()) {
155    char remoteData;
156    radio.read(&remoteData, sizeof(remoteData));
157
158
159    if (remoteData == 'F') {
160
161      forward(); // Go Forward
162      digitalWrite(LeftLED, HIGH);
163      digitalWrite(RightLED, HIGH);
164      digitalWrite(ReverseLED, LOW);
165      digitalWrite(SignalLED, HIGH);
166    }
167
168    else if (remoteData == 'B') {
169
170      backward(); //Go Backword
171      digitalWrite(LeftLED, LOW);
172      digitalWrite(RightLED, LOW);
173      digitalWrite(ReverseLED, HIGH);
174      digitalWrite(SignalLED, HIGH);
175    }
176
177    else if (remoteData == 'L') {
178
179      turnLeft();  //Turn Left
180      digitalWrite(LeftLED, HIGH);
181      digitalWrite(RightLED, LOW);
182      digitalWrite(ReverseLED, LOW);
183      digitalWrite(SignalLED, HIGH);
184    }
185
186    else if (remoteData == 'R') {
187
188      turnRight();  //Turn Right
189      digitalWrite(LeftLED, LOW);
190      digitalWrite(RightLED, HIGH);
191      digitalWrite(ReverseLED, LOW);
192      digitalWrite(SignalLED, HIGH);
193
194
195    } else if (remoteData == 'A') {
196      reset = 0;
197      digitalWrite(SignalLED, HIGH);
198      digitalWrite(SLED, HIGH);
199      if (angle >= 0) {  
200        angle--;
201        delay(10);
202        TopServo.write(angle);
203      }
204
205    }
206
207    else if (remoteData == 'D') {
208
209      reset = 0;
210      digitalWrite(RSLED, HIGH);
211
212      digitalWrite(SignalLED, HIGH);
213
214      if (angle <= 180) {  // Ensure angle doesn't exceed Top_Servo's maximum angle
215        angle++;
216        delay(10);
217        TopServo.write(angle);
218      }
219
220
221    }
222
223    else if (remoteData == 'M') {
224
225      digitalWrite(SignalLED, HIGH);
226
227      if (Camangle >= 0) {  
228        Camangle--;
229        delay(10);
230        CamServo.write(Camangle);
231      }
232
233    }
234
235    else if (remoteData == 'N') {
236
237
238      reset = 0;
239
240      digitalWrite(SignalLED, HIGH);
241
242      if (Camangle <= 180) {  // Ensure angle doesn't exceed Top_Servo's maximum angle
243        Camangle++;
244        delay(10);
245        CamServo.write(Camangle);
246      }
247
248
249    }
250
251    else if (remoteData == 'Y') { //to reset  state of fire detecting
252
253      reset = 0;
254
255      digitalWrite(SignalLED, HIGH);
256      digitalWrite(FlameLed, LOW);
257
258
259    }
260
261
262     else if (remoteData == 'K') { //to reset  state of fire detecting
263
264      
265
266      digitalWrite(SignalLED, HIGH);
267      Camangle = 90;
268        delay(10);
269        CamServo.write(Camangle);
270
271    }
272
273
274
275    else if (remoteData == 'S') {
276
277      stop();
278      digitalWrite(LeftLED, HIGH);
279      digitalWrite(RightLED, HIGH);
280      digitalWrite(SignalLED, LOW);
281      currentTime = millis();     //Light Blinking 
282      if (currentTime - previousTime >= interval) {
283        previousTime = currentTime;
284        if (ledStateblink == LOW) {
285          ledStateblink = HIGH;
286        } else {
287          ledStateblink = LOW;
288        }
289        digitalWrite(ReverseLED, ledStateblink);
290        digitalWrite(SignalLED, ledStateblink);
291      }
292
293      
294
295    } else if (remoteData == 'W') {
296
297     
298      pumpstate = !pumpstate;
299
300      digitalWrite(SignalLED, HIGH);
301      delay(50);
302
303      digitalWrite(SLED, HIGH);
304      digitalWrite(PumpLED, pumpstate);
305      digitalWrite(WPump, !pumpstate);
306
307      return;
308      
309    }
310    else if (remoteData == 'Z') {
311
312      flasState = !flasState;
313
314      digitalWrite(SignalLED, HIGH);
315      delay(50);
316
317      
318      digitalWrite(Flasher, !flasState);
319
320      return;
321    }
322  }
323}
324
325
326
327
328
329
330// Motor controller functions
331void forward() {
332  digitalWrite(LFM, HIGH);
333  digitalWrite(RFM, HIGH);
334  digitalWrite(LBM, LOW);
335  digitalWrite(RBM, LOW);
336}
337
338void backward() {
339  digitalWrite(LFM, LOW);
340  digitalWrite(RFM, LOW);
341  digitalWrite(LBM, HIGH);
342  digitalWrite(RBM, HIGH);
343}
344
345void turnLeft() {
346  digitalWrite(LFM, LOW);
347  digitalWrite(RFM, HIGH);
348  digitalWrite(LBM, HIGH);
349  digitalWrite(RBM, LOW);
350}
351
352void turnRight() {
353  digitalWrite(LFM, HIGH);
354  digitalWrite(RFM, LOW);
355  digitalWrite(LBM, LOW);
356  digitalWrite(RBM, HIGH);
357}
358
359void stop() {
360  digitalWrite(LFM, LOW);
361  digitalWrite(RFM, LOW);
362  digitalWrite(LBM, LOW);
363  digitalWrite(RBM, LOW);
364}