1. /********* Pleasedontcode.com **********
  2.  
  3.     Pleasedontcode thanks you for automatic code generation! Enjoy your code!
  4.  
  5.     - Terms and Conditions:
  6.     You have a non-exclusive, revocable, worldwide, royalty-free license
  7.     for personal and commercial use. Attribution is optional; modifications
  8.     are allowed, but you're responsible for code maintenance. We're not
  9.     liable for any loss or damage. For full terms,
  10.     please visit pleasedontcode.com/termsandconditions.
  11.  
  12.     - Project: **Fall Detection**
  13.     - Source Code NOT compiled for: Arduino Uno
  14.     - Source Code created on: 2025-06-09 05:34:17
  15.  
  16. ********* Pleasedontcode.com **********/
  17.  
  18. /****** SYSTEM REQUIREMENTS *****/
  19. /****** SYSTEM REQUIREMENT 1 *****/
  20.     /* it wont reset after i pressed cancellation button */
  21. /****** END SYSTEM REQUIREMENTS *****/
  22.  
  23. /* START CODE */
  24.  
  25. /****** DEFINITION OF LIBRARIES *****/
  26. #include <EasyButton.h> //https://github.com/evert-arias/EasyButton
  27. #include "TinyGPS.h" // Include TinyGPS library
  28. #include "SoftwareSerial.h" // Include SoftwareSerial library
  29.  
  30. /****** FUNCTION PROTOTYPES *****/
  31. void setup(void);
  32. void loop(void);
  33.  
  34. /***** DEFINITION OF DIGITAL INPUT PINS *****/
  35. const uint8_t cancellationbutton_PushButton_PIN_D2      = 2;
  36. #define buttonPin 8 // Confirmation button
  37. #define cancelButtonPin 7 // Cancellation button
  38.  
  39. /***** DEFINITION OF DIGITAL OUTPUT PINS *****/
  40. const uint8_t myLED_LED_PIN_D3      = 3;
  41. #define buzzerPin 6 // Buzzer pin
  42. #define ledPin 5 // LED pin
  43.  
  44. /***** DEFINITION OF OUTPUT RAW VARIABLES *****/
  45. /***** used to store raw data *****/
  46. bool    myLED_LED_PIN_D3_rawData        = 0;
  47.  
  48. /***** DEFINITION OF OUTPUT PHYSICAL VARIABLES *****/
  49. /***** used to store data after characteristic curve transformation *****/
  50. float   myLED_LED_PIN_D3_phyData        = 0.0;
  51.  
  52. /****** DEFINITION OF LIBRARIES CLASS INSTANCES*****/
  53. SoftwareSerial GPRS(2,3); // RX=pin 2, TX=pin 3
  54. SoftwareSerial serial_connection(10, 11); // RX=pin 10, TX=pin 11
  55. TinyGPSPlus gps; // This is the GPS object that will work with the NMEA data
  56.  
  57. // Pins and variables declarations
  58. float latitude=0;
  59. float longitude=0;                      
  60. String Speed="";
  61. int Contrast=20;
  62.  
  63. // Accelerometer pins
  64. #define x A1
  65. #define y A2
  66. #define z A3
  67.  
  68. // Pulse Sensor pin
  69. #define pulseSensorPin A0
  70.  
  71. // Variables corresponding to accelerometer
  72. int xsample=0;
  73. int ysample=0;
  74. int zsample=0;
  75.  
  76. #define samples 10 // number of sample readings in still case
  77. #define fallThreshold 650 // Fall Detection Threshold
  78.  
  79. // Threshold maximum and minimum values of change in acceleration when fall is detected
  80. #define minVal -50
  81. #define MaxVal 50
  82.  
  83. // Variables tracking button state
  84. bool isFallDetected = false;
  85. bool isFallConfirmed = false;
  86. bool isFallCancelled = false;
  87.  
  88. // Assign timing
  89. unsigned long fallTime; // when fall is detected
  90. unsigned long confirmationTimeout = 5000; // Time wait for confirmation or cancellation button is 5 seconds
  91. unsigned long confirmationWaitTime; // Time to wait for confirmation
  92.  
  93. // Pulse sensor variables
  94. int pulseValue = 0;
  95. unsigned long lastBeatTime = 0; // Last time heartbeat detected
  96. unsigned long beatInterval = 0; // Time interval between beats
  97. int heartRate = 0; // heart rate in BPM
  98. int pulseThreshold = 512; // default threshold for pulse
  99.  
  100. // Function declarations
  101. void triggerFallConfirmation();
  102. void sendAlert();
  103. void resetPotentiometer();
  104.  
  105. void setup(void)
  106. {
  107.     // put your setup code here, to run once:
  108.     Serial.begin(9600); // Start serial communication
  109.     serial_connection.begin(9600); // This opens up communications to the GPS
  110.     Serial.println("successfully Initialized....");
  111.     Serial.println("GPS Start"); // Just show to the monitor that the sketch has started
  112.    
  113.     // Taking samples in still case
  114.     for(int i=0; i<samples; i++)  
  115.     {    
  116.         xsample += analogRead(x);    
  117.         ysample += analogRead(y);    
  118.         zsample += analogRead(z);  
  119.     }    
  120.  
  121.     // Taking average
  122.     xsample /= samples;  
  123.     ysample /= samples;  
  124.     zsample /= samples;  
  125.     Serial.println(xsample);  
  126.     Serial.println(ysample);  
  127.     Serial.println(zsample);  
  128.     delay(1000);  
  129.  
  130.     // Set pin mode for button, buzzer and led  
  131.     pinMode(cancellationbutton_PushButton_PIN_D2, INPUT_PULLUP);
  132.     pinMode(buttonPin, INPUT_PULLUP); // Confirmation button  
  133.     pinMode(cancelButtonPin, INPUT_PULLUP); // Cancellation button  
  134.     pinMode(buzzerPin, OUTPUT); // Buzzer pin  
  135.     pinMode(ledPin, OUTPUT); // LED pin  
  136.     pinMode(pulseSensorPin, INPUT); // Pulse sensor pin  
  137. }
  138.  
  139. void loop(void)
  140. {
  141.     // put your main code here, to run repeatedly:
  142.     updateOutputs(); // Refresh output data
  143.    
  144.     while(serial_connection.available()) // While there are characters to come from the GPS  
  145.     {    
  146.         gps.encode(serial_connection.read()); // This feeds the serial NMEA data into the library one char at a time      
  147.     }  
  148.     if(gps.location.isUpdated())  
  149.     {    
  150.         // Get the latest info from the gps object which it derived from the data sent by the GPS unit    
  151.         Serial.println("Satellite Count : ");    
  152.         Serial.println(gps.satellites.value());    
  153.         Serial.println("Latitude : ");    
  154.         Serial.println(gps.location.lat(), 6);    
  155.         Serial.println("Longitude : ");    
  156.         Serial.println(gps.location.lng(), 6);    
  157.         Serial.println("Speed MPH : ");    
  158.         Serial.println(gps.speed.mph());    
  159.         Serial.println("Altitude Feet : ");    
  160.         Serial.println(gps.altitude.feet());    
  161.         Serial.println("");  
  162.     }  
  163.  
  164.     int value1 = analogRead(x);    
  165.     int value2 = analogRead(y);    
  166.     int value3 = analogRead(z);    
  167.     int xValue = xsample - value1;    
  168.     int yValue = ysample - value2;    
  169.     int zValue = zsample - value3;        
  170.  
  171.     Serial.print("x=");    
  172.     Serial.println(xValue);    
  173.     Serial.print("y=");    
  174.     Serial.println(yValue);    
  175.     Serial.print("z=");    
  176.     Serial.println(zValue);    
  177.  
  178.     // Pulse sensor reading    
  179.     pulseValue = analogRead(pulseSensorPin); // Read value from x axis potentiometer    
  180.     pulseThreshold = map(analogRead(x), 0, 1023, 400, 600); // Adjust threshold range (400-600)    
  181.     Serial.print("Pulse Value : ");    
  182.     Serial.println(pulseValue);    
  183.     Serial.print("Pulse Threshold : ");    
  184.     Serial.println(pulseThreshold);    
  185.  
  186.     if(pulseValue > pulseThreshold)    
  187.     {      
  188.         if(millis() - lastBeatTime > 500) // Only count a beat every 500ms (roughly 60BPM)        
  189.         {        
  190.             heartRate = 60000 / (millis() - lastBeatTime); // Calculate heart rate in beats per minute        
  191.             lastBeatTime = millis();        
  192.             Serial.print("Heart Rate : ");        
  193.             Serial.println(heartRate);        
  194.             // Check if heart rate is abnormal        
  195.             if(heartRate < MIN_HEART_RATE || heartRate > MAX_HEART_RATE)        
  196.             {          
  197.                 Serial.println("Abnormal heart rate detected. Please confirm if fall has occured.");          
  198.                 triggerFallConfirmation(); // Confirm whether there's a fall or not        
  199.             }              
  200.         }    
  201.     }  
  202.  
  203.     // Condition for Fall Detection    
  204.     if(xValue < minVal || xValue > MaxVal || yValue < minVal || yValue > MaxVal || zValue < minVal || zValue > MaxVal)    
  205.     { // Fall Detected, send SMS to emergency contact        
  206.         Serial.println("Fall Detected, Please press the button to confirm...");        
  207.         isFallDetected = true; // When fall is detected                
  208.        
  209.         // Buzzer and LED on when fall is detected        
  210.         digitalWrite(buzzerPin, HIGH); // Buzzer On        
  211.         digitalWrite(ledPin, HIGH); // LED on        
  212.         fallTime = millis(); // Record time when fall is detected        
  213.         confirmationWaitTime = fallTime + confirmationTimeout; // Set timeout time for confirmation        
  214.  
  215.         // Confirmation button        
  216.         while (!isFallConfirmed && !isFallCancelled && millis() < confirmationWaitTime)        
  217.         {          
  218.             // Wait for confirmation or cancellation button press          
  219.             if (digitalRead(buttonPin) == LOW) // If confirmation button is pressed            
  220.             {            
  221.                 isFallConfirmed = true;            
  222.                 Serial.println("Fall is confirmed!");            
  223.                 sendAlert(); // Send SMS alert            
  224.                 break; // Exit loop once fall is confirmed          
  225.             }          
  226.             if (digitalRead(cancelButtonPin) == LOW)            
  227.             {            
  228.                 isFallCancelled = true; // If cancellation button is pressed            
  229.                 Serial.println("Fall Detection cancelled");            
  230.                 // Do not reset the state after cancellation
  231.                 digitalWrite(buzzerPin, LOW); // Buzzer off            
  232.                 digitalWrite(ledPin, LOW); // LED off            
  233.                 break;          
  234.             }                  
  235.         }        
  236.  
  237.         // If no confirmation or cancellation button is pressed, automatically confirm the fall        
  238.         if(!isFallConfirmed && millis() >= confirmationWaitTime)
  239.         {          
  240.             isFallConfirmed = true;          
  241.             Serial.println("No response, fall Detection is confirmed");          
  242.             sendAlert(); // send SMS automatically        
  243.         }        
  244.  
  245.         // After confirmation or cancellation, reset fall detection        
  246.         if (isFallCancelled)        
  247.         {          
  248.             resetPotentiometer(); // Reset Potentiometer values after confirmation          
  249.             isFallDetected = false;          
  250.             isFallConfirmed = false;          
  251.             // Do not reset isFallCancelled to allow for further cancellations
  252.             Serial.println("Fall Detection reset.");          
  253.             // Reset after cancellation and continue monitoring          
  254.             digitalWrite(buzzerPin, LOW); // Buzzer off          
  255.             digitalWrite(ledPin, LOW); // LED off        
  256.         }        
  257.     }      
  258.     delay(1000);
  259. }
  260.  
  261. void updateOutputs()
  262. {
  263.     digitalWrite(myLED_LED_PIN_D3, myLED_LED_PIN_D3_rawData);
  264. }
  265.  
  266. // Send SMS alert
  267. void sendAlert()
  268. {  
  269.     // Initialize GPRS module        
  270.     GPRS.begin(9600);        
  271.     Serial.println("Connecting to network...");        
  272.     delay(2000); // wait for network connection        
  273.     Serial.println("Should be connected to network by now");        
  274.    
  275.     // Send SMS alerts with location        
  276.     GPRS.print("AT+CMGF=1\r"); // set SMS format to text mode        
  277.     delay(1200);        
  278.     GPRS.print("AT+CMGS=\"+01xxxxxxxxx\"\r"); // Set phone number to send alert with (replace with actual number)
  279.     delay(1200);                
  280.    
  281.     // Message        
  282.     GPRS.print("Fall Detected!");        
  283.     GPRS.print("Location:\n");        
  284.     GPRS.print("Latitude : ");        
  285.     GPRS.print(latitude);        
  286.     GPRS.print("\nLongitude : ");        
  287.     GPRS.print("\nGoogle Maps Link: http://maps.google.com/maps?&z=15&mrt=yp&t=k&q=");        
  288.     GPRS.println(latitude);        
  289.     GPRS.println("+");        
  290.     GPRS.println(longitude);        
  291.     GPRS.write(26); // Send SMS        
  292.     GPRS.println("SMS Sent!");      
  293. }
  294.  
  295. // Function resetting potentiometer
  296. void resetPotentiometer()
  297. {  
  298.     xsample = 0;  
  299.     ysample = 0;  
  300.     zsample = 0;  
  301.     for(int i = 0; i < samples; i++)
  302.     {    
  303.         xsample += analogRead(x);    
  304.         ysample += analogRead(y);    
  305.         zsample += analogRead(z);  
  306.     }  
  307.     // Average after reset  
  308.     xsample /= samples;  
  309.     ysample /= samples;  
  310.     zsample /= samples;  
  311.     Serial.println("Potentiometer reset values: ");  
  312.     Serial.println(xsample);  
  313.     Serial.println(ysample);  
  314.     Serial.println(zsample);
  315. }
  316.  
  317. // Trigger fall confirmation based on abnormal heart rate
  318. void triggerFallConfirmation()
  319. {  
  320.     Serial.println("Please press the confirmation button if fall has occured.");
  321. }
  322.  
  323. /* END CODE */