Sunday, August 31, 2025

ANTIKETHERA MECHANISM TANIK

 #include <Wire.h>

#include <RTClib.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

//
// ---- Display config ----
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET    -1         // Reset pin not used with I2C
#define OLED_ADDR     0x3C       // Change to 0x3D if your OLED uses that
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

//
// ---- RTC ----
RTC_DS3231 rtc;

//
// ---- Constants for astronomy approximations ----
// Reference new moon: 2000-01-06 18:14 UT (JD ≈ 2451550.1)
// Source: common approximation epoch for simple moon phase calc
const double NEW_MOON_JD_REF = 2451550.1;
const double SYNODIC_MONTH   = 29.53058867;

//
// ---- Utility: convert date/time to (approx) Julian Day ----
double julianDay(int y, int m, int d, int hh, int mm, int ss) {
  // Fliegel–Van Flandern algorithm (works for Gregorian dates)
  if (m <= 2) { y -= 1; m += 12; }
  int A = y / 100;
  int B = 2 - A + (A / 4);
  long C = (long)(365.25 * (y + 4716));
  long D = (long)(30.6001 * (m + 1));
  double dayFrac = (hh + (mm/60.0) + (ss/3600.0)) / 24.0;
  return C + D + d + B - 1524.5 + dayFrac;
}

//
// ---- Moon phase: age (days) and illumination (approx) ----
void moonPhase(double jd, double &ageDays, int &illumPercent) {
  double lunations = (jd - NEW_MOON_JD_REF) / SYNODIC_MONTH;
  double frac = lunations - floor(lunations);
  ageDays = frac * SYNODIC_MONTH;                            // 0..29.53
  // Illumination approximation using a simple cosine model
  // phase angle ≈ 2π * frac; illumination = (1 - cos(phase))/2
  double phaseAngle = 2.0 * PI * frac;
  double illum = 0.5 * (1.0 - cos(phaseAngle));
  illumPercent = (int)round(illum * 100.0);
}

//
// ---- Tropical zodiac from date (rough, by date ranges) ----
// Uses common Western (tropical) zodiac date boundaries.
const char* zodiacFromDate(int m, int d) {
  // date as MMDD integer for easy comparison
  int md = m*100 + d;
  if ((md >= 321  && md <= 419 )) return "Aries";
  if ((md >= 420  && md <= 520 )) return "Taurus";
  if ((md >= 521  && md <= 620 )) return "Gemini";
  if ((md >= 621  && md <= 722 )) return "Cancer";
  if ((md >= 723  && md <= 822 )) return "Leo";
  if ((md >= 823  && md <= 922 )) return "Virgo";
  if ((md >= 923  && md <= 1022)) return "Libra";
  if ((md >= 1023 && md <= 1121)) return "Scorpio";
  if ((md >= 1122 && md <= 1221)) return "Sagittarius";
  // Capricorn wraps year end
  if (md >= 1222 || md <= 119)   return "Capricorn";
  if ((md >= 120  && md <= 218 )) return "Aquarius";
  return "Pisces"; // 2/19–3/20
}

//
// ---- Cycles: Metonic (19y), Callippic (76y), Olympiad (4y) ----
int metonicYear(int year)   { return (year % 19) == 0 ? 19 : (year % 19); }
int callippicYear(int year) { int r = year % 76; return r == 0 ? 76 : r; }
int olympiadYear(int year)  { int r = year % 4;  return r == 0 ? 4  : r;  }

//
// ---- Optional: set RTC once from compile time ----
// Set to true on first upload to set the RTC, then set back to false.
bool SET_RTC_FROM_COMPILE_TIME = false;

void setup() {
  // I2C
  Wire.begin(21, 22); // ESP32 default pins; adjust if needed

  // Serial (debug)
  Serial.begin(115200);
  delay(200);

  // Display init
  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
    // If it fails, try other address or wiring
    for (;;){
      Serial.println("SSD1306 init failed. Check wiring/address.");
      delay(2000);
    }
  }
  display.clearDisplay();
  display.display();

  // RTC init
  if (!rtc.begin()) {
    showFatal("RTC not found!");
  }
  if (rtc.lostPower()) {
    Serial.println("RTC lost power, setting time to compile time.");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  } else if (SET_RTC_FROM_COMPILE_TIME) {
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
}

void loop() {
  DateTime now = rtc.now();

  // Build Julian Day
  double jd = julianDay(now.year(), now.month(), now.day(),
                        now.hour(), now.minute(), now.second());

  // Moon
  double ageDays;
  int illum;
  moonPhase(jd, ageDays, illum);

  // Zodiac & cycles
  const char* zodiac = zodiacFromDate(now.month(), now.day());
  int metonic   = metonicYear(now.year());
  int callippic = callippicYear(now.year());
  int olympiad  = olympiadYear(now.year());

  // ---- Draw ----
  display.clearDisplay();

  // Header: time
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  char buf[32];
  sprintf(buf, "%02d:%02d:%02d", now.hour(), now.minute(), now.second());
  display.println(buf);

  // Date line
  sprintf(buf, "%04d-%02d-%02d", now.year(), now.month(), now.day());
  display.println(buf);

  // Moon line
  // Age with 1 decimal
  char moonBuf[32];
  dtostrf(ageDays, 5, 1, moonBuf);
  display.print("Moon: ");
  display.print(moonBuf);
  display.print(" d  ");
  display.print(illum);
  display.println("%");

  // Zodiac
  display.print("Zodiac: ");
  display.println(zodiac);

  // Cycles
  display.print("Metonic: ");
  display.print(metonic);
  display.print("  Callippic: ");
  display.println(callippic);

  display.print("Olympiad: ");
  display.print(olympiad);
  display.println(" of 4");

  // Tiny “phase bar”
  // Draw a simple horizontal bar to visualize illumination
  int barX = 0, barY = 56, barW = 128, barH = 8;
  display.drawRect(barX, barY, barW, barH, SSD1306_WHITE);
  int fillW = map(illum, 0, 100, 0, barW - 2);
  display.fillRect(barX + 1, barY + 1, fillW, barH - 2, SSD1306_WHITE);

  display.display();

  delay(250); // refresh ~4 fps
}

void showFatal(const char* msg) {
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("FATAL:");
  display.println(msg);
  display.display();
  while (true) { delay(1000); }
}

Saturday, August 30, 2025

4:00PM_GTM_KRIDAY_GREEN_BIN_DONE

ARDUINO CODE:


#include <Servo.h>

Servo servoBio;     // Servo for biodegradable bin
Servo servoNonBio;  // Servo for non-biodegradable bin

String inputString = "";
unsigned long lastActionTime = 0; // cooldown timer
const unsigned long cooldown = 1500; // 1.5 sec between actions

void setup() {
  Serial.begin(9600);
  servoBio.attach(9);       // Biodegradable servo
  servoNonBio.attach(10);   // Non-biodegradable servo

  servoBio.write(0);
  servoNonBio.write(0);

  Serial.println("Arduino ready");
}

void loop() {
  if (Serial.available() > 0) {
    inputString = Serial.readStringUntil('\n');
    inputString.trim();  // Remove spaces and newlines

    Serial.print("Received: ");
    Serial.println(inputString);

    // Enforce cooldown — ignore new command if last action too recent
    if (millis() - lastActionTime < cooldown) {
      return;
    }

    if (inputString.equalsIgnoreCase("BIO")) {
      servoNonBio.write(0);          // Make sure non-bio stays closed
      servoBio.write(120);           // Open bio bin
      delay(800);
      servoBio.write(0);             // Close bio bin
      lastActionTime = millis();
    }
    else if (inputString.equalsIgnoreCase("NONBIO")) {
      servoBio.write(0);             // Make sure bio stays closed
      servoNonBio.write(120);        // Open non-bio bin
      delay(800);
      servoNonBio.write(0);          // Close non-bio bin
      lastActionTime = millis();
    }
    else if (inputString.equalsIgnoreCase("NONE")) {
      servoBio.write(0);
      servoNonBio.write(0);
    }
  }
}




VS JAVA CODE



<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Smart Waste Sorter</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            text-align: center;
            background: #f4f4f4;
            margin: 0;
            padding: 20px;
        }
        #webcam-container { margin-top: 20px; }
        #label-container div { padding: 5px; font-size: 16px; }
        #command-log { margin-top: 20px; font-weight: bold; color: blue; }
        button {
            padding: 10px 20px;
            margin: 5px;
            font-size: 16px;
            border: none;
            border-radius: 5px;
            background: #007bff;
            color: white;
            cursor: pointer;
        }
        button:hover { background: #0056b3; }
    </style>
</head>
<body>
    <h1>Teachable Machine Image Model</h1>
    <button onclick="init()">Start Detection</button>
    <button onclick="initSerial()">Connect Arduino</button>
    <div id="webcam-container"></div>
    <div id="label-container"></div>
    <div id="command-log">Command to Arduino: (not sent yet)</div>

    <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@latest/dist/tf.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/@teachablemachine/image@latest/dist/teachablemachine-image.min.js"></script>
    <script>
    const URL = "https://teachablemachine.withgoogle.com/models/AY_02yWWo/";
    let model, webcam, labelContainer, maxPredictions;
    let port, writer;
    let lastCmd = "";
    let lastSendTime = 0;
    const sendCooldown = 1000; // 1 second between sends

    // Auto reconnect
    navigator.serial.addEventListener("disconnect", async () => {
        document.getElementById("command-log").innerHTML =
            "Arduino disconnected. Trying to reconnect...";
        console.warn("Arduino disconnected. Reconnecting...");
        try { await initSerial(); }
        catch (err) { console.error("Auto-reconnect failed:", err); }
    });

    async function initSerial() {
        try {
            if (!port) {
                port = await navigator.serial.requestPort();
            }
            await port.open({ baudRate: 9600 });
            writer = port.writable.getWriter();
            document.getElementById("command-log").innerHTML = "Serial connected to Arduino!";
            console.log("Serial connected to Arduino!");
        } catch (err) {
            console.error("Serial connection failed:", err);
            document.getElementById("command-log").innerHTML = "Serial connection failed!";
        }
    }

    async function sendCommand(cmd) {
        const now = Date.now();
        if (cmd === lastCmd || now - lastSendTime < sendCooldown) {
            return; // ignore duplicate or too fast commands
        }
        lastCmd = cmd;
        lastSendTime = now;

        if (writer) {
            const data = new TextEncoder().encode(cmd + "\n");
            await writer.write(data);
            console.log("Sent to Arduino:", cmd);
            document.getElementById("command-log").innerHTML = "Command to Arduino: " + cmd;
        } else {
            console.warn("Command not sent — Arduino not connected:", cmd);
            document.getElementById("command-log").innerHTML =
                "Arduino not connected. Last command: " + cmd;
        }
    }

    async function init() {
        const modelURL = URL + "model.json";
        const metadataURL = URL + "metadata.json";
        model = await tmImage.load(modelURL, metadataURL);
        maxPredictions = model.getTotalClasses();

        const flip = true;
        webcam = new tmImage.Webcam(200, 200, flip);
        await webcam.setup();
        await webcam.play();
        window.requestAnimationFrame(loop);

        document.getElementById("webcam-container").appendChild(webcam.canvas);
        labelContainer = document.getElementById("label-container");
        for (let i = 0; i < maxPredictions; i++) {
            labelContainer.appendChild(document.createElement("div"));
        }
    }

    async function loop() {
        webcam.update();
        await predict();
        window.requestAnimationFrame(loop);
    }

    async function predict() {
        const prediction = await model.predict(webcam.canvas);
        for (let i = 0; i < maxPredictions; i++) {
            labelContainer.childNodes[i].innerHTML =
                prediction[i].className + ": " + prediction[i].probability.toFixed(2);
        }

        // Find highest probability
        let maxIndex = 0;
        for (let i = 1; i < prediction.length; i++) {
            if (prediction[i].probability > prediction[maxIndex].probability) {
                maxIndex = i;
            }
        }
        const detectedClass = prediction[maxIndex].className.toLowerCase();

        if (detectedClass.includes("bio") && !detectedClass.includes("non")) {
            sendCommand("BIO");
        } else if (detectedClass.includes("non")) {
            sendCommand("NONBIO");
        } else {
            sendCommand("NONE");
        }
    }
    </script>
</body>
</html>


SOME ERROR STILL EXIST

Kriday_Green_Bin_Auto_Sorter_GTM_30 AUG ALL SOURCES

//     LINK TRAINED MODEL:   https://teachablemachine.withgoogle.com/models/AY_02yWWo/


<div>Teachable Machine Image Model</div>

<button type="button" onclick="init()">Start</button>

<div id="webcam-container"></div>

<div id="label-container"></div>

<script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@latest/dist/tf.min.js"></script>

<script src="https://cdn.jsdelivr.net/npm/@teachablemachine/image@latest/dist/teachablemachine-image.min.js"></script>

<script type="text/javascript">

    // More API functions here:

    // https://github.com/googlecreativelab/teachablemachine-community/tree/master/libraries/image


    // the link to your model provided by Teachable Machine export panel

    const URL = "https://teachablemachine.withgoogle.com/models/AY_02yWWo/";


    let model, webcam, labelContainer, maxPredictions;


    // Load the image model and setup the webcam

    async function init() {

        const modelURL = URL + "model.json";

        const metadataURL = URL + "metadata.json";


        // load the model and metadata

        // Refer to tmImage.loadFromFiles() in the API to support files from a file picker

        // or files from your local hard drive

        // Note: the pose library adds "tmImage" object to your window (window.tmImage)

        model = await tmImage.load(modelURL, metadataURL);

        maxPredictions = model.getTotalClasses();


        // Convenience function to setup a webcam

        const flip = true; // whether to flip the webcam

        webcam = new tmImage.Webcam(200, 200, flip); // width, height, flip

        await webcam.setup(); // request access to the webcam

        await webcam.play();

        window.requestAnimationFrame(loop);


        // append elements to the DOM

        document.getElementById("webcam-container").appendChild(webcam.canvas);

        labelContainer = document.getElementById("label-container");

        for (let i = 0; i < maxPredictions; i++) { // and class labels

            labelContainer.appendChild(document.createElement("div"));

        }

    }


    async function loop() {

        webcam.update(); // update the webcam frame

        await predict();

        window.requestAnimationFrame(loop);

    }


    // run the webcam image through the image model

    async function predict() {

        // predict can take in an image, video or canvas html element

        const prediction = await model.predict(webcam.canvas);

        for (let i = 0; i < maxPredictions; i++) {

            const classPrediction =

                prediction[i].className + ": " + prediction[i].probability.toFixed(2);

            labelContainer.childNodes[i].innerHTML = classPrediction;

        }

    }

</script>


Thursday, August 28, 2025

WASTE_WATER_MANAGEMENT_SERVO_RIMT_UNIVERSITY_GOOGLE_TEACHABLE_MACHINE_LADAKH

// SERVO ROTATING MULTIPLE TIME 

 <!DOCTYPE html>

<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Teachable Machine + Arduino (Safe)</title>
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
 
  <!-- TensorFlow.js and Teachable Machine image library (browser-safe builds) -->
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@latest/dist/tf.min.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/@teachablemachine/image@latest/dist/teachablemachine-image.min.js"></script>

  <style>
    body { font-family: Arial, sans-serif; padding: 20px; }
    h2 { color: #333; }
    button { padding: 10px 15px; margin: 5px; cursor: pointer; }
    #webcam-container, #label-container { margin-top: 15px; }
    .error { color: red; margin-top: 10px; }
    .status { margin-top: 10px; color: green; }
  </style>
</head>
<body>
  <h2>Teachable Machine Image Model + Arduino Uno (Safe Version)</h2>

  <button onclick="init()">Start Camera & Model</button>
  <button onclick="connectToArduino()">Connect to Arduino</button>
  <button onclick="sendManualCommand()">Send TEST Command</button>

  <div id="webcam-container"></div>
  <div id="label-container"></div>
  <div id="status" class="status"></div>
  <div id="error" class="error"></div>

  <script>
    const URL = "https://teachablemachine.withgoogle.com/models/gXFa-npbx/";
    let model, webcam, labelContainer, maxPredictions;
    let port, writer;

    function setStatus(msg) {
      document.getElementById("status").textContent = msg;
    }
    function setError(msg) {
      document.getElementById("error").textContent = msg;
    }

    // Initialize Teachable Machine model and webcam
    async function init() {
      setError("");
      setStatus("Loading model...");
     
      if (typeof tmImage === "undefined") {
        setError("ERROR: Teachable Machine library did not load.");
        return;
      }

      try {
        const modelURL = URL + "model.json";
        const metadataURL = URL + "metadata.json";

        model = await tmImage.load(modelURL, metadataURL);
        maxPredictions = model.getTotalClasses();

        const flip = true;
        webcam = new tmImage.Webcam(200, 200, flip);

        await webcam.setup();
        await webcam.play();
        window.requestAnimationFrame(loop);

        document.getElementById("webcam-container").appendChild(webcam.canvas);
        labelContainer = document.getElementById("label-container");
        labelContainer.innerHTML = "";
        for (let i = 0; i < maxPredictions; i++) {
          labelContainer.appendChild(document.createElement("div"));
        }
        setStatus("Model and webcam started.");
      } catch (err) {
        setError("Webcam or model failed: " + err.message);
        console.error(err);
      }
    }

    async function loop() {
      if (webcam && webcam.canvas) {
        webcam.update();
        await predict();
      }
      window.requestAnimationFrame(loop);
    }

    async function predict() {
      if (!model || !webcam || !webcam.canvas) return;

      const prediction = await model.predict(webcam.canvas);
      let detectedClass = "";

      for (let i = 0; i < maxPredictions; i++) {
        const classPrediction = prediction[i].className + ": " + prediction[i].probability.toFixed(2);
        labelContainer.childNodes[i].innerHTML = classPrediction;

        if (prediction[i].probability > 0.8) {
          detectedClass = prediction[i].className;
        }
      }

      if (detectedClass && writer) {
        let cleanLabel = detectedClass.toLowerCase().trim().replace(/[^a-z0-9 ]/g, "");
        console.log("Detected:", cleanLabel);
        try {
          await writer.write(new TextEncoder().encode(cleanLabel + "\n"));
        } catch (err) {
          setError("Failed to send to Arduino: " + err.message);
          console.error(err);
        }
      }
    }

    async function connectToArduino() {
      setError("");
      setStatus("Requesting Arduino port...");
     
      if (!("serial" in navigator)) {
        setError("Web Serial API not supported in this browser.");
        return;
      }

      try {
        port = await navigator.serial.requestPort(); // user must pick port
        await port.open({ baudRate: 9600 });
        writer = port.writable.getWriter();
        setStatus("Connected to Arduino successfully.");
      } catch (err) {
        if (err.name === "NotFoundError") {
          setError("No port selected by user.");
        } else {
          setError("Could not connect to Arduino: " + err.message);
        }
        console.error(err);
      }
    }

    async function sendManualCommand() {
      if (!writer) {
        setError("Arduino not connected.");
        return;
      }
      try {
        await writer.write(new TextEncoder().encode("test\n"));
        setStatus("TEST command sent to Arduino");
        console.log("TEST command sent to Arduino");
      } catch (err) {
        setError("Failed to send test command: " + err.message);
      }
    }
  </script>
</body>
</html>




//ARDUINO CODE

#include <Servo.h>
Servo myServo;
int servoPin = 9;
String inputString = "";

String sanitize(String s) {
  s.trim();
  s.toLowerCase();
  String clean = "";
  for (int i = 0; i < s.length(); i++) {
    char c = s.charAt(i);
    if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == ' ') {
      clean += c;
    }
  }
  return clean;
}

void setup() {
  Serial.begin(9600);
  myServo.attach(servoPin);
  myServo.write(0);  // initial position
  Serial.println("Arduino ready");
}

void loop() {
  while (Serial.available() > 0) {
    char c = Serial.read();
    if (c == '\n') {
      inputString = sanitize(inputString);
      Serial.print("Command received: ");
      Serial.println(inputString);

      if (inputString == "waste water") {
        myServo.write(160);  // CHANGED angle to 160°
        Serial.println("Servo -> 160°");
      }
      else if (inputString == "motor stay off") {
        myServo.write(0);
        Serial.println("Servo -> 0°");
      }
      inputString = "";
    } else {
      inputString += c;
    }
  }
}




LADAKH TRAINED MODEL


<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Teachable Machine + Arduino (Safe)</title>
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <!-- TensorFlow.js and Teachable Machine image library (browser-safe builds) -->
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@latest/dist/tf.min.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/@teachablemachine/image@latest/dist/teachablemachine-image.min.js"></script>
  <style>
    body { font-family: Arial, sans-serif; padding: 20px; }
    h2 { color: #333; }
    button { padding: 10px 15px; margin: 5px; cursor: pointer; }
    #webcam-container, #label-container { margin-top: 15px; }
    .error { color: red; margin-top: 10px; }
    .status { margin-top: 10px; color: green; }
  </style>
</head>
<body>
  <h2>Teachable Machine Image Model + Arduino Uno (Safe Version)</h2>
  <button onclick="init()">Start Camera & Model</button>
  <button onclick="connectToArduino()">Connect to Arduino</button>
  <button onclick="sendManualCommand()">Send TEST Command</button>
  <div id="webcam-container"></div>
  <div id="label-container"></div>
  <div id="status" class="status"></div>
  <div id="error" class="error"></div>

  <script>
    const URL = "https://teachablemachine.withgoogle.com/models/tPVETubWb/";
    let model, webcam, labelContainer, maxPredictions;
    let port, writer;

    function setStatus(msg) { document.getElementById("status").textContent = msg; }
    function setError(msg) { document.getElementById("error").textContent = msg; }

    // Initialize Teachable Machine model and webcam
    async function init() {
      setError("");
      setStatus("Loading model...");
      if (typeof tmImage === "undefined") {
        setError("ERROR: Teachable Machine library did not load.");
        return;
      }
      try {
        const modelURL = URL + "model.json";
        const metadataURL = URL + "metadata.json";
        model = await tmImage.load(modelURL, metadataURL);
        maxPredictions = model.getTotalClasses();

        const flip = true;
        webcam = new tmImage.Webcam(200, 200, flip);
        await webcam.setup();
        await webcam.play();
        window.requestAnimationFrame(loop);
        document.getElementById("webcam-container").appendChild(webcam.canvas);

        labelContainer = document.getElementById("label-container");
        labelContainer.innerHTML = "";
        for (let i = 0; i < maxPredictions; i++) {
          labelContainer.appendChild(document.createElement("div"));
        }

        setStatus("Model and webcam started.");
      } catch (err) {
        setError("Webcam or model failed: " + err.message);
        console.error(err);
      }
    }

    async function loop() {
      if (webcam && webcam.canvas) {
        webcam.update();
        await predict();
      }
      window.requestAnimationFrame(loop);
    }

    async function predict() {
      if (!model || !webcam || !webcam.canvas) return;
      const prediction = await model.predict(webcam.canvas);
      let detectedClass = "";
      for (let i = 0; i < maxPredictions; i++) {
        const classPrediction = prediction[i].className + ": " + prediction[i].probability.toFixed(2);
        labelContainer.childNodes[i].innerHTML = classPrediction;
        if (prediction[i].probability > 0.8) {
          detectedClass = prediction[i].className;
        }
      }
      if (detectedClass && writer) {
        let cleanLabel = detectedClass.toLowerCase().trim().replace(/[^a-z0-9 ]/g, "");
        console.log("Detected:", cleanLabel);
        try {
          await writer.write(new TextEncoder().encode(cleanLabel + "\n"));
        } catch (err) {
          setError("Failed to send to Arduino: " + err.message);
          console.error(err);
        }
      }
    }

    async function connectToArduino() {
      setError("");
      setStatus("Requesting Arduino port...");
      if (!("serial" in navigator)) {
        setError("Web Serial API not supported in this browser.");
        return;
      }
      try {
        port = await navigator.serial.requestPort();
        await port.open({ baudRate: 9600 });
        writer = port.writable.getWriter();
        setStatus("Connected to Arduino successfully.");
      } catch (err) {
        if (err.name === "NotFoundError") {
          setError("No port selected by user.");
        } else {
          setError("Could not connect to Arduino: " + err.message);
        }
        console.error(err);
      }
    }

    async function sendManualCommand() {
      if (!writer) {
        setError("Arduino not connected.");
        return;
      }
      try {
        await writer.write(new TextEncoder().encode("test\n"));
        setStatus("TEST command sent to Arduino");
        console.log("TEST command sent to Arduino");
      } catch (err) {
        setError("Failed to send test command: " + err.message);
      }
    }
  </script>
</body>
</html>


MUD Three Mode operation Manual Automatic GPS

 Code for three mode operation: /*   3-Mode Headlight Controller   - Manual mode (driver uses a toggle to pick high/low)   - Auto mode (LDR...