Control shelly with a NTC Sensor

// Brief description:
// - Periodically reads voltage from a thermistor via a voltmeter component
// - Converts voltage to temperature using Steinhart-Hart equation
// - Writes calculated temperature to a virtual component
// - Retrieves desired temperature (either static or from virtual component)
// - Applies hysteresis and optional inversion to control a relay based on temperature

// SH Coefficient Calculator
// https://rusefi.com/Steinhart-Hart.html
//
// Thermistor wiki page
// https://en.wikipedia.org/wiki/Thermistor

/**************** START CHANGE HERE ****************/
let CONFIG = {
  scanInterval: 10, // seconds, the script runs every 10 seconds to fetch the voltage
  voltmeterID: 100, // ID of the voltmeter - when we install the plugin, the device defines this number

  // Desired temperature settings
  useVirtualDesiredTemp: true, // Set to true to use a virtual component for the desired temperature
  desiredTemp: 25,             // Desired temperature in Celsius (used if useVirtualDesiredTemp is false)
  hysteresis: 1,               // Hysteresis band in degrees Celsius
  invertRelay: false,          // Set to true to invert the relay action

  /**
   * Applies math to the voltage and returns the result. This function is called every time the voltage is measured
   * @param {Number} voltage The currently measured voltage
   * @returns The temperature based on the voltage
   */
  calcTemp: function (voltage) {
    const constVoltage = 10;
    const R1 = 10000;
    const A = 0.0010377385695278978;
    const B = 0.00021633455581572119;
    const C = 2.654857502585547e-7;

    const R2 = R1 * (voltage / (constVoltage - voltage));
    const logR2 = Math.log(R2);
    let T = 1.0 / (A + (B + C * logR2 * logR2) * logR2);
    T = T - 273.15; // Celsius

    console.log(
      "Current Temperature: " +
        T.toFixed(2) +
        " °C | Voltage: " +
        voltage +
        "V | Resistance: " +
        R2.toFixed(2) +
        "Ω"
    );

    return T;
  },

  /**
   * This function is called every time a temperature is read
   * @param {Number} temperature The currently calculated temperature
   * @param {Number} desiredTemp The desired temperature
   */
  onTempReading: function (temperature, desiredTemp) {
    // Fetch the current relay status
    let switchStatus = Shelly.getComponentStatus("switch:0");
    if (switchStatus === null || typeof switchStatus.output !== "boolean") {
      console.log("Cannot read relay status");
      return;
    }
    let relayIsOn = switchStatus.output; // true or false

    // Calculate thresholds
    let onThreshold = desiredTemp - CONFIG.hysteresis / 2;
    let offThreshold = desiredTemp + CONFIG.hysteresis / 2;

    let turnRelayOn = false;
    let turnRelayOff = false;

    if (!CONFIG.invertRelay) {
      // Normal operation
      if (!relayIsOn && temperature < onThreshold) {
        turnRelayOn = true;
      } else if (relayIsOn && temperature > offThreshold) {
        turnRelayOff = true;
      }
    } else {
      // Inverted operation
      if (!relayIsOn && temperature > offThreshold) {
        turnRelayOn = true;
      } else if (relayIsOn && temperature < onThreshold) {
        turnRelayOff = true;
      }
    }

    if (turnRelayOn) {
      // Turn relay on
      Shelly.call("Switch.Set", { id: 0, on: true });
      console.log("Turning relay on");
    } else if (turnRelayOff) {
      // Turn relay off
      Shelly.call("Switch.Set", { id: 0, on: false });
      console.log("Turning relay off");
    } else {
      // No relay action needed
      console.log("No relay action needed");
    }
  },
};
/**************** STOP CHANGE HERE ****************/

function fetchVoltage() {
  // Fetch the voltmeter component
  const voltmeter = Shelly.getComponentStatus(
    "voltmeter:" + JSON.stringify(CONFIG.voltmeterID)
  );

  // Exit if component does not exist
  if (typeof voltmeter === "undefined" || voltmeter === null) {
    console.log("Cannot find voltmeter component");
    return;
  }

  const voltage = voltmeter["voltage"];

  // Exit if voltage cannot be read
  if (typeof voltage !== "number") {
    console.log("Cannot read the voltage or it is NaN");
    return;
  }

  // Calculate the temperature based on the voltage
  const temp = CONFIG.calcTemp(voltage);
  // Write temperature to virtual component with id 200
  Shelly.call("Number.Set", { id: 200, value: Number(temp.toFixed(2)) });
  print("Temperature " + temp.toFixed(2) + " °C written to Virtual component (Id:200)");

  // Exit if temperature was not calculated correctly
  if (typeof temp !== "number") {
    console.log("Something went wrong calculating the temperature");
    return;
  }

  // Fetch desired temperature if necessary
  if (CONFIG.useVirtualDesiredTemp) {
    Shelly.call(
      "Number.GetStatus",
      { id: 201 },
      function (result, error_code, error_message) {
        if (error_code === 0 && result && typeof result.value === "number") {
          let desiredTemp = result.value;
          console.log("Desired temperature fetched from virtual component: " + desiredTemp + " °C");
          CONFIG.onTempReading(temp, desiredTemp);
        } else {
          console.log("Error fetching desired temperature: " + error_message);
          // Handle error, maybe use default desired temperature
          CONFIG.onTempReading(temp, CONFIG.desiredTemp);
        }
      }
    );
  } else {
    // Use desired temperature from CONFIG
    CONFIG.onTempReading(temp, CONFIG.desiredTemp);
  }
}

// Initialize the script
function init() {
  // Start the timer
  Timer.set(CONFIG.scanInterval * 1000, true, fetchVoltage);

  // Fetch voltage at startup
  fetchVoltage();
}

init();