Week 15 – Interface and Application Programming

  
  #include <BLEDevice.h>
  #include <BLEUtils.h>
  #include <BLEServer.h>
  #include <Adafruit_NeoPixel.h>

  // Use the GPIO number directly for the XIAO S3
  #define LED_PIN    D9      
  #define LED_COUNT  25

  Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

  // Unique IDs for your Garba Costume
  #define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
  #define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

  class MyCallbacks: public BLECharacteristicCallbacks {
      void onWrite(BLECharacteristic *pCharacteristic) {
        // FIX: Use Arduino 'String' instead of 'std::string'
        String value = pCharacteristic->getValue(); 
        
        if (value.length() == 3) {
          // Accessing indices works the same way
          uint8_t r = (uint8_t)value[0];
          uint8_t g = (uint8_t)value[1];
          uint8_t b = (uint8_t)value[2];
          
          for(int i=0; icreateService(SERVICE_UUID);
    
    BLECharacteristic *pCharacteristic = pService->createCharacteristic(
                                          CHARACTERISTIC_UUID,
                                          BLECharacteristic::PROPERTY_READ |
                                          BLECharacteristic::PROPERTY_WRITE
                                        );

    pCharacteristic->setCallbacks(new MyCallbacks());
    pService->start();
    
    BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
    pAdvertising->addServiceUUID(SERVICE_UUID);
    pAdvertising->setScanResponse(true);
    pAdvertising->setMinPreferred(0x06);  
    pAdvertising->setMinPreferred(0x12);
    BLEDevice::startAdvertising();
    
    Serial.println("Characteristic defined! Now gradient-scanning on your phone...");
  }

  void loop() {
    // Nothing needed here for now, callbacks handle the work!
    delay(2000);
  }
        

    #include <BLEDevice.h>
    #include <BLEUtils.h>
    #include <BLEServer.h>
    #include <Adafruit_NeoPixel.h>

    #define LED_PIN    D9      
    #define LED_COUNT  25
    Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

    // Unique IDs
    #define SERVICE_UUID           "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
    #define COLOR_CHAR_UUID        "beb5483e-36e1-4688-b7f5-ea07361b26a8"
    #define BRIGHTNESS_CHAR_UUID   "d211246c-7e61-456a-93a0-f80076a598c1"

    class ColorCallbacks: public BLECharacteristicCallbacks {
        void onWrite(BLECharacteristic *pCharacteristic) {
          String value = pCharacteristic->getValue();
          if (value.length() == 3) {
            strip.setPixelColor(0, strip.Color((uint8_t)value[0], (uint8_t)value[1], (uint8_t)value[2]));
            for(int i=1; igetValue();
          if (value.length() > 0) {
            uint8_t b = (uint8_t)value[0];
            strip.setBrightness(b);
            strip.show();
            Serial.printf("Brightness set to: %d\n", b);
          }
        }
    };

    void setup() {
      Serial.begin(115200);
      strip.begin();
      strip.setBrightness(50); // Start dim for safety
      strip.show();

      BLEDevice::init("Garba-Sync-01");
      BLEServer *pServer = BLEDevice::createServer();
      BLEService *pService = pServer->createService(SERVICE_UUID);

      // Color Characteristic
      BLECharacteristic *pColorChar = pService->createCharacteristic(COLOR_CHAR_UUID, BLECharacteristic::PROPERTY_WRITE);
      pColorChar->setCallbacks(new ColorCallbacks());

      // Brightness Characteristic
      BLECharacteristic *pBrightChar = pService->createCharacteristic(BRIGHTNESS_CHAR_UUID, BLECharacteristic::PROPERTY_WRITE);
      pBrightChar->setCallbacks(new BrightnessCallbacks());

      pService->start();
      BLEDevice::startAdvertising();
      Serial.println("Ready! Connect via nRF Connect.");
    }

    void loop() { delay(10); }

    

// Test Code for GPS Module - this code will read the GPS coordinates and print them to the Serial Monitor.
// --- LIBRARIES ---
#include          // The library that turns messy GPS "sentences" into numbers
#include     // Allows us to create a second serial port for the GPS
#include  // Controls your 25 LEDs

// --- PIN DEFINITIONS ---
#define LED_PIN    D3    // Data pin for Neopixels (moved to D3 to avoid LoRa conflict)
#define LED_COUNT  25   // Total number of LEDs in your strip
#define GPS_RX     D7    // XIAO Pin D7 (Connect to GPS TX)
#define GPS_TX     D6    // XIAO Pin D6 (Connect to GPS RX)

// --- OBJECT INITIALIZATION ---
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); // Create the LED strip object
TinyGPSPlus gps;                // Create the GPS "parser" object to handle data
HardwareSerial SerialGPS(1);    // Create a new Serial port (Serial1) on the ESP32 hardware

void setup() {
  // Start the standard Serial for the Computer (Serial Monitor) at 115200 baud
  Serial.begin(115200);
  
  // Initialize Neopixels
  strip.begin();
  strip.setBrightness(50);
  strip.fill(strip.Color(0, 0, 255)); // Set color to BLUE (indicates "System OK, searching for GPS")
  strip.show();

  // Initialize GPS communication. 9600 is the factory standard for NEO-6M modules.
  // We tell the ESP32 to use Pins 7 (RX) and 6 (TX) for this specific serial link.
  SerialGPS.begin(9600, SERIAL_8N1, GPS_RX, GPS_TX);
  
  Serial.println("Spiral 3: GPS Test Starting...");
}

void loop() {
  // 1. DATA FEEDING: This loop checks if the GPS module is sending any bytes.
  while (SerialGPS.available() > 0) {
    // gps.encode() takes the raw characters one-by-one and looks for a valid GPS "sentence."
    // It returns 'true' only when it has a complete, valid packet of information.
    if (gps.encode(SerialGPS.read())) {
      displayGPSInfo(); // If a valid packet is ready, go to the display function
    }
  }

  // 2. ERROR CHECK: If 5 seconds pass and no data characters have been processed,
  // it usually means the TX/RX wires are swapped or loose.
  if (millis() > 5000 && gps.charsProcessed() < 10) {
    Serial.println("No GPS detected: check wiring (TX to D7, RX to D6)");
    delay(2000);
  }
}

// --- DISPLAY FUNCTION ---
void displayGPSInfo() {
  // Check if the library successfully calculated a location from the satellites
  if (gps.location.isValid()) {
    // Print Latitude and Longitude with 6 decimal places of precision
    Serial.print("Location: ");
    Serial.print(gps.location.lat(), 6);
    Serial.print(",");
    Serial.println(gps.location.lng(), 6);
    
    // VISUAL FEEDBACK: Change LEDs to GREEN to show the user the "Friend-Finder" is ready
    strip.fill(strip.Color(0, 255, 0));
    strip.show();
  } else {
    // If we have a connection to the module but not enough satellites yet
    Serial.println("Waiting for Satellites... (Go near a window)");
  }
}
  

        
        #include <RadioLib.h>
        #include <TinyGPS++.h>
        #include <HardwareSerial.h>
        #include <Adafruit_NeoPixel.h>

        // --- 1. PIN DEFINITIONS ---
        // LoRa Pins (Official Seeed B2B Mapping for XIAO ESP32S3)
        #define LORA_CS    41
        #define LORA_DIO1  39
        #define LORA_BUSY  40
        #define LORA_NRST  42

        // GPS Pins (XIAO Side Headers)
        #define GPS_RX     D7    // Connect to GPS TX
        #define GPS_TX     D6    // Connect to GPS RX

        // Neopixel Pin (Move to D3 to stay clear of I2C/SPI)
        #define LED_PIN    D3    
        #define LED_COUNT  25

        // --- 2. OBJECT INITIALIZATION ---
        SX1262 radio = new Module(LORA_CS, LORA_DIO1, LORA_NRST, LORA_BUSY);
        TinyGPSPlus gps;
        HardwareSerial SerialGPS(1); // Use UART1
        Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

        // Timing variables
        unsigned long lastSendTime = 0;
        const int sendInterval = 10000; // Broadcast every 10 seconds

        void setup() {
          Serial.begin(115200);
          while(!Serial); // Wait for monitor
          delay(1000);

          // Initialize LEDs
          strip.begin();
          strip.setBrightness(50);
          strip.fill(strip.Color(0, 0, 255)); // Start Blue (Searching)
          strip.show();

          // Initialize GPS Serial
          SerialGPS.begin(9600, SERIAL_8N1, GPS_RX, GPS_TX);

          // Initialize LoRa Radio
          Serial.println(F("\n--- Garba-Sync Spiral 3 Boot ---"));
          Serial.print(F("[LoRa] Initializing... "));
          
          // 868.0 for India/Europe, 915.0 for Americas
          int state = radio.begin(868.0); 

          if (state == RADIOLIB_ERR_NONE) {
            Serial.println(F("Success!"));
          } else {
            Serial.print(F("Failed, code ")); Serial.println(state);
            strip.fill(strip.Color(255, 0, 0)); // Red for Radio Failure
            strip.show();
            while (true);
          }
        }

        void loop() {
          // 3. AGGRESSIVE GPS FEED
          // We read every single character from GPS to prevent buffer overflow
          while (SerialGPS.available() > 0) {
            gps.encode(SerialGPS.read());
          }

          // 4. PERIODIC DATA UPLOAD (Every 10 Seconds)
          if (millis() - lastSendTime > sendInterval) {
            
            // Print Debug Info to Serial Monitor
            Serial.print(F("Satellites: ")); Serial.print(gps.satellites.value());
            Serial.print(F(" | Lat: ")); Serial.print(gps.location.lat(), 6);
            Serial.print(F(" | Lng: ")); Serial.println(gps.location.lng(), 6);

            if (gps.location.isValid() && gps.location.age() < 2000) {
              // Create the packet string
              String msg = "ID:Sync-01,LAT:" + String(gps.location.lat(), 6) + ",LNG:" + String(gps.location.lng(), 6);
              
              Serial.print(F("[LoRa] Broadcasting Location... "));
              int state = radio.transmit(msg);

              if (state == RADIOLIB_ERR_NONE) {
                Serial.println(F("Done!"));
                flashLED(strip.Color(0, 255, 0)); // Flash Green on success
              } else {
                Serial.print(F("Error: ")); Serial.println(state);
              }
            } 
            else {
              // Visual feedback while waiting for lock
              if(gps.satellites.value() > 0) {
                strip.fill(strip.Color(255, 255, 0)); // Yellow = Seeing sats, but no lock yet
              } else {
                strip.fill(strip.Color(0, 0, 255));   // Blue = No satellites seen
              }
              strip.show();
              Serial.println(F("[GPS] Waiting for valid 3D Lock..."));
            }
            
            lastSendTime = millis();
          }
        }

        // Function to flash LEDs briefly
        void flashLED(uint32_t color) {
          strip.fill(color);
          strip.show();
          delay(300);
          strip.fill(0);
          strip.show();
        }
        

  /* * GARBA-SYNC MASTER FIRMWARE (Spiral 3.5)
  * Integrated GPS, LoRa (868MHz), and BLE (Bluetooth Low Energy)
  */
 
  #include <BLEDevice.h>         // Enables Bluetooth Low Energy functionality
  #include <BLEUtils.h>          // BLE helper functions
  #include <BLEServer.h>         // Enables the XIAO to act as a BLE Server (Peripheral)
  #include <RadioLib.h>          // Controls the SX1262 LoRa Module
  #include <TinyGPS++.h>         // Parses raw NMEA data from GPS into readable Lat/Lng
  #include <HardwareSerial.h>    // Manages UART communication for the GPS module
  #include <Adafruit_NeoPixel.h> // Controls the RGB LED ring

  // BLE UUIDs: These are unique "addresses" for your app to find specific features.
  // Service UUID: The main "folder" for your device's features.
  #define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
  // Brightness Characteristic UUID: The specific "file" the app writes to for LED control.
  #define BRIGHT_CHAR_UUID    "beb5483e-36e1-4688-b7f5-ea07361b26a8"

  // LoRa Pin definitions for the XIAO ESP32S3 B2B (Board-to-Board) connector
  #define LORA_CS    41   // Chip Select
  #define LORA_DIO1  39   // Data Input/Output 1 (Interrupt)
  #define LORA_BUSY  40   // Busy status pin
  #define LORA_NRST  42   // Hardware Reset

  // GPS and LED Pins connected to the XIAO headers
  #define GPS_RX     D7   // Connect to GPS Module TX
  #define GPS_TX     D6   // Connect to GPS Module RX
  #define LED_PIN    D3   // Data pin for the Neopixels
  #define LED_COUNT  25   // Number of LEDs in the ring

  // --- OBJECT INITIALIZATION ---
  // Create LoRa instance using the SX1262 module and specific pins
  SX1262 radio = new Module(LORA_CS, LORA_DIO1, LORA_NRST, LORA_BUSY);

  // Create GPS parser instance
  TinyGPSPlus gps;

  // Define a Hardware Serial port (Serial1) for the GPS module
  HardwareSerial SerialGPS(1);

  // Initialize Neopixel strip
  Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

  // Global variables for system state
  int currentBrightness = 50;     // Initial LED brightness (0-255)
  unsigned long lastSendTime = 0; // Stores the timestamp of the last LoRa transmission

  // --- BLE CALLBACK CLASS ---
  // This class "listens" for data coming from your Mobile App
  class MyCallbacks: public BLECharacteristicCallbacks {
      // This function runs automatically whenever you send data from the App
      void onWrite(BLECharacteristic *pCharacteristic) {
        // Retrieve the data sent from the phone app
        String value = pCharacteristic->getValue(); 

        if (value.length() > 0) {
          // We take the first byte of data and use it to set LED brightness
          currentBrightness = (int)value[0];
          strip.setBrightness(currentBrightness);
          strip.show(); // Update the physical LEDs immediately
          
          Serial.print("App Update -> New Brightness: ");
          Serial.println(currentBrightness);
        }
      }
  };

  void setup() {
    // Start the standard Serial Monitor for debugging
    Serial.begin(115200);
    
    // 1. INITIALIZE LEDs
    strip.begin();
    strip.setBrightness(currentBrightness);
    strip.fill(strip.Color(255, 0, 255)); // Set Purple color (Indicates "Booting/BLE Active")
    strip.show();

    // 2. INITIALIZE BLE (Bluetooth)
    BLEDevice::init("Garba-Sync-Badge");             // Set the name seen by your phone
    BLEServer *pServer = BLEDevice::createServer();    // Create the BLE server instance
    BLEService *pService = pServer->createService(SERVICE_UUID); // Start the main service
    
    // Create the "Brightness" characteristic so the app can talk to the badge
    BLECharacteristic *pChar = pService->createCharacteristic(
                                  BRIGHT_CHAR_UUID, 
                                  BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_WRITE
                              );
                              
    pChar->setCallbacks(new MyCallbacks());            // Link the app logic to the code above
    pService->start();                                 // Start the service
    BLEDevice::getAdvertising()->start();              // Start "broadcasting" so phone can find it

    // 3. INITIALIZE GPS & LoRa
    SerialGPS.begin(9600, SERIAL_8N1, GPS_RX, GPS_TX); // Start GPS serial communication
    int state = radio.begin(868.0);                    // Initialize LoRa radio at 868MHz
    
    if (state == RADIOLIB_ERR_NONE) {
      Serial.println("System Online: BLE, GPS, and LoRa Active.");
    } else {
      // If radio fails, print error code (check B2B connection if this happens)
      Serial.print("LoRa Failed, code: "); Serial.println(state);
    }
  }

  void loop() {
    // --- GPS LOGIC ---
    // Constantly "feed" every character coming from the GPS module into the TinyGPS parser
    while (SerialGPS.available() > 0) {
      gps.encode(SerialGPS.read());
    }

    // --- LoRa BROADCAST LOGIC ---
    // Use a non-blocking timer to send data every 10 seconds (10000ms)
    if (millis() - lastSendTime > 10000) {
      
      // Check if the GPS has successfully found its location (Lock)
      if (gps.location.isValid()) {
        // Create a data packet: ID of badge, Latitude, and Longitude
        String msg = "ID:01,LAT:" + String(gps.location.lat(), 6) + ",LNG:" + String(gps.location.lng(), 6);
        
        // Send the location packet into the air via LoRa
        radio.transmit(msg);
        
        Serial.println("LoRa Broadcast Sent: " + msg);
      } else {
        // If GPS isn't ready yet, we wait (usually requires being near a window or outside)
        Serial.println("Waiting for GPS fix to broadcast...");
      }
      
      lastSendTime = millis(); // Reset the 10-second timer
    }
  }