Create Me Esp 32 Model Components Given Below

#include <Arduino.h>
#include <SPI.h>
#include <RF24.h>
#include <TinyGPS++.h>
#include <NewPing.h>

// Use the labels printed on the ESP32: for example, G16 means GPIO16.

// Hoisted type definitions
struct RescueMessage {
  uint16_t distanceCm;
  uint8_t confidencePercent;
  uint8_t flags; // bit 0: nearby object, bit 1: GPS location valid
  int32_t latitudeE6;
  int32_t longitudeE6;
};


// Forward declarations
void readGps();
void updateDistance();
uint8_t rescueConfidence(bool gpsFix);
void startBeep(uint32_t now);
void updateBuzzer(uint32_t now, bool gpsFix);
void updateLed(uint32_t now, bool gpsFix);
void transmitRescueMessage(bool gpsFix);

constexpr uint8_t GPS_RX_PIN = 16;
constexpr uint8_t GPS_TX_PIN = 17;
constexpr uint8_t ULTRASONIC_TRIG_PIN = 25;
constexpr uint8_t ULTRASONIC_ECHO_PIN = 32;
constexpr uint8_t LED_PIN = 26;
constexpr uint8_t BUZZER_PIN = 33;
constexpr uint8_t RADIO_CE_PIN = 27;
constexpr uint8_t RADIO_CSN_PIN = 4;
constexpr uint8_t RADIO_SCK_PIN = 18;
constexpr uint8_t RADIO_MISO_PIN = 19;
constexpr uint8_t RADIO_MOSI_PIN = 23;

constexpr uint16_t MAX_DISTANCE_CM = 400;
constexpr uint16_t NEARBY_DISTANCE_CM = 100;
constexpr uint32_t DISTANCE_INTERVAL_MS = 250;
constexpr uint32_t RADIO_INTERVAL_MS = 1000;
constexpr uint32_t GPS_BLINK_INTERVAL_MS = 500;
constexpr uint32_t ALERT_BLINK_INTERVAL_MS = 125;
constexpr uint32_t BEEP_INTERVAL_MS = 300;
constexpr uint32_t BEEP_LENGTH_MS = 35;

const byte RADIO_ADDRESS[6] = "RSC01";



TinyGPSPlus gps;
HardwareSerial gpsSerial(2);
NewPing sonar(ULTRASONIC_TRIG_PIN, ULTRASONIC_ECHO_PIN, MAX_DISTANCE_CM);
RF24 radio(RADIO_CE_PIN, RADIO_CSN_PIN);

uint16_t distanceCm = 0;
bool objectNearby = false;
bool hadGpsFix = false;
bool radioReady = false;
bool buzzerOn = false;
uint32_t lastDistanceMs = 0;
uint32_t lastRadioMs = 0;
uint32_t lastBeepMs = 0;
uint32_t beepStartedMs = 0;

void readGps() {
  while (gpsSerial.available() > 0) {
    gps.encode(gpsSerial.read());
  }
}

void updateDistance() {
  distanceCm = sonar.ping_cm();
  objectNearby = distanceCm > 0 && distanceCm <= NEARBY_DISTANCE_CM;
}

uint8_t rescueConfidence(bool gpsFix) {
  // This is an indication for rescuers, not a human-identification result.
  uint8_t score = 0;
  if (objectNearby) score += 60;
  if (gpsFix) score += 30;
  if (radioReady) score += 10;
  return score;
}

void startBeep(uint32_t now) {
  digitalWrite(BUZZER_PIN, HIGH);
  buzzerOn = true;
  beepStartedMs = now;
}

void updateBuzzer(uint32_t now, bool gpsFix) {
  if (buzzerOn && now - beepStartedMs >= BEEP_LENGTH_MS) {
    digitalWrite(BUZZER_PIN, LOW);
    buzzerOn = false;
  }
  if (objectNearby && !buzzerOn && now - lastBeepMs >= BEEP_INTERVAL_MS) {
    lastBeepMs = now;
    startBeep(now);
  }
  if (gpsFix && !hadGpsFix && !buzzerOn) {
    startBeep(now);
  }
  hadGpsFix = gpsFix;
}

void updateLed(uint32_t now, bool gpsFix) {
  if (objectNearby) {
    digitalWrite(LED_PIN, ((now / ALERT_BLINK_INTERVAL_MS) % 2) == 0 ? HIGH : LOW);
  } else if (gpsFix) {
    digitalWrite(LED_PIN, HIGH);
  } else {
    digitalWrite(LED_PIN, ((now / GPS_BLINK_INTERVAL_MS) % 2) == 0 ? HIGH : LOW);
  }
}

void transmitRescueMessage(bool gpsFix) {
  if (!radioReady) return;

  RescueMessage message{};
  message.distanceCm = distanceCm;
  message.confidencePercent = rescueConfidence(gpsFix);
  message.flags = (objectNearby ? 0x01 : 0x00) | (gpsFix ? 0x02 : 0x00);
  if (gpsFix) {
    message.latitudeE6 = static_cast<int32_t>(gps.location.lat() * 1000000.0);
    message.longitudeE6 = static_cast<int32_t>(gps.location.lng() * 1000000.0);
  }

  radio.stopListening();
  const bool sent = radio.write(&message, sizeof(message));
  Serial.printf("Distance: %u cm | GPS: %s | rescue indication: %u%% | radio: %s\n",
                distanceCm, gpsFix ? "valid" : "searching", message.confidencePercent,
                sent ? "sent" : "no receiver acknowledgement");
}

void setup() {
  Serial.begin(115200);
  gpsSerial.begin(9600, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
  digitalWrite(BUZZER_PIN, LOW);

  SPI.begin(RADIO_SCK_PIN, RADIO_MISO_PIN, RADIO_MOSI_PIN, RADIO_CSN_PIN);
  radioReady = radio.begin();
  if (radioReady) {
    radio.setPALevel(RF24_PA_LOW);
    radio.setDataRate(RF24_250KBPS);
    radio.openWritingPipe(RADIO_ADDRESS);
    radio.stopListening();
  }
  Serial.println("Disaster-rescue indicator started.");
}

void loop() {
  const uint32_t now = millis();
  readGps();
  if (now - lastDistanceMs >= DISTANCE_INTERVAL_MS) {
    lastDistanceMs = now;
    updateDistance();
  }

  const bool gpsFix = gps.location.isValid();
  updateLed(now, gpsFix);
  updateBuzzer(now, gpsFix);

  if (now - lastRadioMs >= RADIO_INTERVAL_MS) {
    lastRadioMs = now;
    transmitRescueMessage(gpsFix);
  }
}