homebridge-frontier-silicon-plugin 0.0.9 → 1.0.0

package/README.md

@@ -3,45 +3,134 @@
 
 [![Build Status](https://travis-ci.org/boikedamhuis/homebridge-frontier-silicon.svg?branch=master)](https://travis-ci.org/boikedamhuis/homebridge-frontier-silicon)
 
-# homebridge-frontier-silicon
+# Homebridge Frontier Silicon Plugin
 
-A Frontier Silicon plugin for homebridge (https://github.com/nfarina/homebridge) which integrates Frontier Silicon enabled devices with Homekit.
+This Homebridge plugin adds basic but reliable HomeKit support for Frontier Silicon based internet radios using the native FSAPI interface.
 
-Plugin updates the status once you open the app, working on real time status updates. Stay tuned :)
+It focuses on stability, simplicity and long term maintainability.  
+Power control and volume control are supported, with safe polling and graceful error handling when a device is temporarily unreachable.
 
-# Installation
+This plugin is designed as a modern replacement for older Frontier Silicon Homebridge integrations.
 
-1. Install homebridge using: `npm install -g homebridge`
-2. Install the package request using: `npm install request -g`
-3. Install the package polling to event using: `npm install polling-to-event -g`
-4. install the package WiFi Radio `npm install wifiradio --save`
-5. Install this plugin: `sudo npm i homebridge-frontier-silicon-plugin`
-6. Update your `config.json` configuration file
+## Features
 
+- Power on and off control through HomeKit  
+- Volume control exposed as a HomeKit slider  
+- Direct FSAPI communication over HTTP  
+- No external or native dependencies  
+- Crash safe behaviour when the radio is offline  
+- Configurable polling interval  
+- Compatible with Raspberry Pi and other low power systems  
 
+## Requirements
 
-```
-"accessories": [ 
-	{
-		"accessory": "homebridge-frontier-silicon",
-		"name": "Radio",
-		"ip": "192.168.1.10"
-   } 
-]
-```   
+- Node.js version 18 or higher  
+- Homebridge version 1.6 or higher  
+- A Frontier Silicon based radio with FSAPI enabled  
 
-Code is based on this repo: https://github.com/rudders/homebridge-http
+Most internet radios from brands such as Roberts, Ruark, Revo, Hama and similar use Frontier Silicon firmware and are compatible.
 
-### Todos
+## Installation
 
- - Volume Change
- - Status Updates
- - Channel Change
- - Clean up the code
- 
+Install the plugin globally using npm
 
-License
-----
+    npm install -g homebridge-frontier-silicon-plugin
 
-MIT
+After installation, restart Homebridge.
 
+## Configuration
+
+Add the accessory to your Homebridge configuration.
+
+### Example configuration
+
+    {
+      "accessory": "frontier-silicon",
+      "name": "Living Room Radio",
+      "ip": "192.168.1.50",
+      "pin": "1234",
+      "pollIntervalSeconds": 5,
+      "enableVolume": true
+    }
+
+## Configuration options
+
+name  
+Displayed name in HomeKit  
+
+ip  
+IP address of the radio  
+
+pin  
+FSAPI PIN code  
+Default is 1234 on most devices  
+
+pollIntervalSeconds  
+Polling interval in seconds  
+Minimum value is 2  
+Default value is 5  
+
+enableVolume  
+Enable volume control  
+Default is true  
+
+## HomeKit behaviour
+
+- The radio power state appears as a Switch accessory  
+- Volume control is exposed as a separate slider using a Lightbulb Brightness characteristic  
+
+If the radio becomes unreachable, HomeKit will continue to show the last known state.  
+Homebridge will not crash or hang.
+
+When the radio becomes reachable again, the state is updated automatically.
+
+## How it works
+
+This plugin communicates directly with the Frontier Silicon FSAPI using HTTP requests.
+
+Power state  
+netRemote.sys.power
+
+Volume  
+netRemote.sys.audio.volume
+
+All requests are executed with timeouts and error handling to ensure Homebridge stability.
+
+## Troubleshooting
+
+The radio does not respond
+
+- Check the IP address  
+- Verify the FSAPI PIN  
+- Make sure the radio is connected to the same network as Homebridge  
+
+HomeKit does not update immediately
+
+- Increase the polling interval  
+- Wait for the next poll cycle  
+
+Enable debug logging in Homebridge for more insight.
+
+## Compatibility notes
+
+Some radios require FSAPI to be enabled in their settings menu.  
+Some models expose volume in a different range, but most work correctly with values from 0 to 100.
+
+If your radio behaves differently, feel free to open an issue.
+
+## Development
+
+This plugin is intentionally kept simple and dependency free.
+
+Possible future improvements include
+
+- Platform plugin support  
+- Homebridge UI configuration schema  
+- Preset or station switching  
+- Mute support  
+
+Contributions and pull requests are welcome.
+
+## License
+
+ISC License

package/index.js

@@ -1,313 +1,244 @@
-var Service, Characteristic;
-var request = require("request");
-var pollingtoevent = require("polling-to-event");
+"use strict";
 
-const wifiradio = require('wifiradio');
+let Service;
+let Characteristic;
 
+module.exports = function (homebridge) {
+  Service = homebridge.hap.Service;
+  Characteristic = homebridge.hap.Characteristic;
+
+  homebridge.registerAccessory(
+    "homebridge-frontier-silicone",
+    "frontier-silicon",
+    FrontierSiliconAccessory
+  );
+};
 
+function FrontierSiliconAccessory(log, config) {
+  this.log = log;
+
+  this.name = config.name || "Frontier Silicon Radio";
+  this.ip = config.ip;
+  this.pin = String(config.pin ?? "1234");
+  this.pollIntervalSeconds = Number(config.pollIntervalSeconds ?? 5);
+  this.enableVolume = config.enableVolume !== false;
+
+  this.lastKnownPower = null;
+  this.lastKnownVolume = null;
+
+  if (!this.ip) {
+    this.log.warn("No ip configured, accessory will not work.");
+  }
+
+  this.client = new FsApiClient({
+    ip: this.ip,
+    pin: this.pin,
+    log: this.log
+  });
+
+  this.switchService = new Service.Switch(this.name);
+
+  this.switchService
+    .getCharacteristic(Characteristic.On)
+    .on("get", this.handleGetPower.bind(this))
+    .on("set", this.handleSetPower.bind(this));
+
+  if (this.enableVolume) {
+    this.volumeService = new Service.Lightbulb(this.name + " Volume");
+    this.volumeService
+      .getCharacteristic(Characteristic.On)
+      .on("get", (cb) => cb(null, true))
+      .on("set", (val, cb) => cb(null));
+
+    this.volumeService
+      .getCharacteristic(Characteristic.Brightness)
+      .on("get", this.handleGetVolume.bind(this))
+      .on("set", this.handleSetVolume.bind(this));
+  }
+
+  this.informationService = new Service.AccessoryInformation()
+    .setCharacteristic(Characteristic.Manufacturer, "Frontier Silicon")
+    .setCharacteristic(Characteristic.Model, "FSAPI Radio")
+    .setCharacteristic(Characteristic.SerialNumber, this.ip || "unknown");
+
+  this.startPolling();
+}
 
-module.exports = function (homebridge) {
-    Service = homebridge.hap.Service;
-    Characteristic = homebridge.hap.Characteristic;
-    homebridge.registerAccessory("homebridge-frontier-silicone", "frontier-silicone", HttpAccessory);
+FrontierSiliconAccessory.prototype.getServices = function () {
+  const services = [this.informationService, this.switchService];
+  if (this.enableVolume && this.volumeService) services.push(this.volumeService);
+  return services;
 };
 
+FrontierSiliconAccessory.prototype.handleGetPower = async function (callback) {
+  try {
+    const power = await this.client.getPower();
+    this.lastKnownPower = power;
+    callback(null, power);
+  } catch (err) {
+    this.log.warn("Power get failed, returning last known state.", toMsg(err));
+    callback(null, this.lastKnownPower ?? false);
+  }
+};
 
-function HttpAccessory(log, config) {
-    this.log = log;
-
-    // url info
-    this.ip = config["ip"];
-    this.on_url = this.ip;
-    this.on_body = this.ip;
-    this.off_url = this.ip;
-    this.off_body = this.ip;
-    this.status_url = "/fsapi/GET/netRemote.sys.power?pin=1234";
-    this.status_on = "FS_OK 1";
-    this.status_off = "FS_OK 0";
-    this.brightness_url = config["brightness_url"];
-    this.brightnesslvl_url = config["brightnesslvl_url"];
-    this.http_method = config["http_method"] || "GET";
-    this.http_brightness_method = config["http_brightness_method"] || this.http_method;
-    this.username = config["username"] || "";
-    this.password = config["password"] || "";
-    this.sendimmediately = config["sendimmediately"] || "";
-    this.service = config["service"] || "Switch";
-    this.name = config["name"];
-    this.brightnessHandling = config["brightnessHandling"] || "no";
-    this.switchHandling = "yes";
-
-	
-    //realtime polling info
-    this.state = false;
-    this.currentlevel = 0;
-    this.enableSet = true;
-    var that = this;
-
-    // Status Polling, if you want to add additional services that don't use switch handling you can add something like this || (this.service=="Smoke" || this.service=="Motion"))
-    if (this.status_url && this.switchHandling === "realtime") {
-        var powerurl = this.status_url;
-        var statusemitter = pollingtoevent(function (done) {
-            
-        }, { longpolling: true, interval: 300, longpollEventName: "statuspoll" });
-
-        function compareStates(customStatus, stateData) {
-            var objectsEqual = true;
-            for (var param in customStatus) {
-                if (!stateData.hasOwnProperty(param) || customStatus[param] !== stateData[param]) {
-                    objectsEqual = false;
-                    break;
-                }
-            }
-            // that.log("Equal", objectsEqual);
-            return objectsEqual;
-        }
+FrontierSiliconAccessory.prototype.handleSetPower = async function (value, callback) {
+  const target = !!value;
+
+  try {
+    await this.client.setPower(target);
+    this.lastKnownPower = target;
+    callback(null);
+  } catch (err) {
+    this.log.warn("Power set failed, keeping last known state.", toMsg(err));
+    callback(null);
+  }
+};
 
-        statusemitter.on("statuspoll", function (responseBody) {
-                var binaryState;
-                this.log("Status Config On", this.status_on);
-                    var customStatusOn = this.status_on;
-                    var customStatusOff = this.status_off;
-                    var statusOn, statusOff;
-
-                    // Check to see if custom states are a json object and if so compare to see if either one matches the state response
-              		const radio = new wifiradio(this.ip, "1234");
-              		
-              	              			              		
-    				 radio.getPower() .then(function(response) {
-						if (response == "1") {
-   						     binaryState = 1;
-
-  					  }
-   						 // else binaryState = 0;
- 						  if (response == "0") {
- 						  binaryState = 0;
-
-   						 }
-    					console.log(response);
-    					callback(null, binaryState);
-						})
-            that.state = binaryState > 0;
-            that.log(that.service, "received power", that.status_url, "state is currently", binaryState);
-            // switch used to easily add additonal services
-            that.enableSet = false;
-            switch (that.service) {
-                case "Switch":
-                    if (that.switchService) {
-                        that.switchService.getCharacteristic(Characteristic.On)
-                        .setValue(that.state);
-                    }
-                    break;
-                case "Light":
-                    if (that.lightbulbService) {
-                        that.lightbulbService.getCharacteristic(Characteristic.On)
-                        .setValue(that.state);
-                    }
-                    break;
-            }
-            that.enableSet = true;
-        });
+FrontierSiliconAccessory.prototype.handleGetVolume = async function (callback) {
+  try {
+    const vol = await this.client.getVolume();
+    this.lastKnownVolume = vol;
+    callback(null, vol);
+  } catch (err) {
+    this.log.warn("Volume get failed, returning last known level.", toMsg(err));
+    callback(null, this.lastKnownVolume ?? 0);
+  }
+};
 
-    }
-    // Brightness Polling
-    if (this.brightnesslvl_url && this.brightnessHandling === "realtime") {
-        var brightnessurl = this.brightnesslvl_url;
-        var levelemitter = pollingtoevent(function (done) {
-            that.httpRequest(brightnessurl, "", "GET", that.username, that.password, that.sendimmediately, function (error, response, responseBody) {
-                if (error) {
-                    that.log("HTTP get power function failed: %s", error.message);
-                    return;
-                } else {
-                    done(null, responseBody);
-                }
-            }) // set longer polling as slider takes longer to set value
-        }, { longpolling: true, interval: 300, longpollEventName: "levelpoll" });
-
-        levelemitter.on("levelpoll", function (responseBody) {
-            that.currentlevel = parseInt(responseBody);
-
-            that.enableSet = false;
-            if (that.lightbulbService) {
-                that.log(that.service, "received brightness", that.brightnesslvl_url, "level is currently", that.currentlevel);
-                that.lightbulbService.getCharacteristic(Characteristic.Brightness)
-                .setValue(that.currentlevel);
-            }
-            that.enableSet = true;
-        });
-    }
-}
+FrontierSiliconAccessory.prototype.handleSetVolume = async function (value, callback) {
+  const vol = clampInt(Number(value), 0, 100);
+
+  try {
+    await this.client.setVolume(vol);
+    this.lastKnownVolume = vol;
+    callback(null);
+  } catch (err) {
+    this.log.warn("Volume set failed, keeping last known level.", toMsg(err));
+    callback(null);
+  }
+};
+
+FrontierSiliconAccessory.prototype.startPolling = function () {
+  if (!this.ip) return;
 
-HttpAccessory.prototype = {
-
-
-
-    setPowerState: function (powerState, callback) {
-        this.log("Power On", powerState);
-        
-        if (this.enableSet === true) {
-
-            var url;
-            var body;
-
-            if (!this.on_url || !this.off_url) {
-                this.log.warn("No IP adress defined");
-                callback(new Error("No power IP defined."));
-                return;
-            }
-			const radio = new wifiradio(this.ip, "1234");
-			
-           if (powerState) {
-
-			
-                radio.setPower(1);
-                
-                body = this.on_body;
-                this.log("Setting power state to on");
-            } else {
-				radio.setPower(0);     
-                this.log("Setting power state to off");
-            }
-            
-            callback();
+  const intervalMs = Math.max(2, this.pollIntervalSeconds) * 1000;
+
+  const tick = async () => {
+    try {
+      const power = await this.client.getPower();
+      if (this.lastKnownPower !== power) {
+        this.lastKnownPower = power;
+        this.switchService.getCharacteristic(Characteristic.On).updateValue(power);
+      }
+    } catch (err) {
+      this.log.debug ? this.log.debug("Polling power failed.", toMsg(err)) : this.log("Polling power failed.");
     }
-    
-},
-
-    getPowerState: function (callback) {
-        if (!this.status_url) {
-            this.log.warn("Ignoring request; No status url defined.");
-            callback(new Error("No status url defined."));
-            return;
-        }
 
-        var url = this.status_url;
-        this.log("Getting power state");
-
-
-                var binaryState;
-                this.log("Status Config On", this.status_on);
-                    var customStatusOn = this.status_on;
-                    var customStatusOff = this.status_off;
-                    var statusOn, statusOff;
-
-                    // Check to see if custom states are a json object and if so compare to see if either one matches the state response
-              		const radio = new wifiradio(this.ip, "1234");
-              		
-              	              			              		
-    				 radio.getPower() .then(function(response) {
-						if (response == "1") {
-   						     binaryState = 1;
-
-  					  }
-   						 // else binaryState = 0;
- 						  if (response == "0") {
- 						  binaryState = 0;
-
-   						 }
-    					console.log(response);
-    					callback(null, binaryState);
-						})
-
-                    
-                    
-                	
-               
-                
-                //var powerOn = binaryState = 0;
-                this.log("Power state is currently %s", binaryState);
-    },
-
-    identify: function (callback) {
-        this.log("Identify requested!");
-        callback(); // success
-    },
-
-    getServices: function () {
-
-        var that = this;
-
-        // you can OPTIONALLY create an information service if you wish to override
-        // the default values for things like serial number, model, etc.
-        var informationService = new Service.AccessoryInformation();
-
-        informationService
-        .setCharacteristic(Characteristic.Manufacturer, "Boike Damhuis")
-        .setCharacteristic(Characteristic.Model, "0.0.8")
-        .setCharacteristic(Characteristic.SerialNumber, "8PC00CAM4B");
-
-        switch (this.service) {
-            case "Switch":
-                this.switchService = new Service.Switch(this.name);
-                switch (this.switchHandling) {
-                    //Power Polling
-                    case "yes":
-                        this.switchService
-                        .getCharacteristic(Characteristic.On)
-                        .on("get", this.getPowerState.bind(this))
-                        .on("set", this.setPowerState.bind(this));
-                        break;
-                    case "realtime":
-                        this.switchService
-                        .getCharacteristic(Characteristic.On)
-                        .on("get", function (callback) {
-                            callback(null, that.state)
-                        })
-                        .on("set", this.setPowerState.bind(this));
-                        break;
-                    default    :
-                        this.switchService
-                        .getCharacteristic(Characteristic.On)
-                        .on("set", this.setPowerState.bind(this));
-                        break;
-                }
-                return [this.switchService];
-            case "Light":
-                this.lightbulbService = new Service.Lightbulb(this.name);
-                switch (this.switchHandling) {
-                    //Power Polling
-                    case "yes" :
-                        this.lightbulbService
-                        .getCharacteristic(Characteristic.On)
-                        .on("get", this.getPowerState.bind(this))
-                        .on("set", this.setPowerState.bind(this));
-                        break;
-                    case "realtime":
-                        this.lightbulbService
-                        .getCharacteristic(Characteristic.On)
-                        .on("get", function (callback) {
-                            callback(null, that.state)
-                        })
-                        .on("set", this.setPowerState.bind(this));
-                        break;
-                    default:
-                        this.lightbulbService
-                        .getCharacteristic(Characteristic.On)
-                        .on("set", this.setPowerState.bind(this));
-                        break;
-                }
-                // Brightness Polling
-                if (this.brightnessHandling === "realtime") {
-                    this.lightbulbService
-                    .addCharacteristic(new Characteristic.Brightness())
-                    .on("get", function (callback) {
-                        callback(null, that.currentlevel)
-                    })
-                    .on("set", this.setBrightness.bind(this));
-                } else if (this.brightnessHandling === "yes") {
-                    this.lightbulbService
-                    .addCharacteristic(new Characteristic.Brightness())
-                    .on("get", this.getBrightness.bind(this))
-                    .on("set", this.setBrightness.bind(this));
-                }
-
-                return [informationService, this.lightbulbService];
-                break;
+    if (this.enableVolume && this.volumeService) {
+      try {
+        const vol = await this.client.getVolume();
+        if (this.lastKnownVolume !== vol) {
+          this.lastKnownVolume = vol;
+          this.volumeService.getCharacteristic(Characteristic.Brightness).updateValue(vol);
         }
+      } catch (err) {
+        this.log.debug ? this.log.debug("Polling volume failed.", toMsg(err)) : this.log("Polling volume failed.");
+      }
     }
+  };
+
+  tick();
+
+  this.pollTimer = setInterval(tick, intervalMs);
+};
+
+function FsApiClient({ ip, pin, log }) {
+  this.ip = ip;
+  this.pin = pin;
+  this.log = log;
+
+  this.baseUrl = "http://" + ip;
+  this.timeoutMs = 2500;
+}
+
+FsApiClient.prototype.getPower = async function () {
+  const text = await this.fetchText("/fsapi/GET/netRemote.sys.power");
+  const value = parseFsapiValue(text);
+  return value === 1;
+};
+
+FsApiClient.prototype.setPower = async function (on) {
+  const v = on ? 1 : 0;
+  await this.fetchText("/fsapi/SET/netRemote.sys.power&value=" + v);
 };
 
+FsApiClient.prototype.getVolume = async function () {
+  const text = await this.fetchText("/fsapi/GET/netRemote.sys.audio.volume");
+  const value = parseFsapiValue(text);
+  return clampInt(Number(value), 0, 100);
+};
+
+FsApiClient.prototype.setVolume = async function (volume) {
+  const v = clampInt(Number(volume), 0, 100);
+  await this.fetchText("/fsapi/SET/netRemote.sys.audio.volume&value=" + v);
+};
 
+FsApiClient.prototype.fetchText = async function (pathAndQuery) {
+  const joiner = pathAndQuery.includes("?") ? "&" : "?";
+  const url = this.baseUrl + pathAndQuery + joiner + "pin=" + encodeURIComponent(this.pin);
 
+  const controller = new AbortController();
+  const t = setTimeout(() => controller.abort(), this.timeoutMs);
+
+  try {
+    const res = await fetch(url, { signal: controller.signal });
+    if (!res.ok) throw new Error("HTTP " + res.status);
+    return await res.text();
+  } finally {
+    clearTimeout(t);
+  }
+};
 
+function parseFsapiValue(body) {
+  if (!body) return null;
 
+  const trimmed = String(body).trim();
 
+  const xmlMatch =
+    trimmed.match(/<value>\s*<u8>(\d+)<\/u8>\s*<\/value>/i) ||
+    trimmed.match(/<value>\s*<u16>(\d+)<\/u16>\s*<\/value>/i) ||
+    trimmed.match(/<value>\s*<u32>(\d+)<\/u32>\s*<\/value>/i) ||
+    trimmed.match(/<value>\s*<s16>(-?\d+)<\/s16>\s*<\/value>/i) ||
+    trimmed.match(/<value>\s*<c8_array>(.*?)<\/c8_array>\s*<\/value>/i);
+
+  if (xmlMatch) {
+    const raw = xmlMatch[1];
+    const num = Number(raw);
+    return Number.isFinite(num) ? num : raw;
+  }
+
+  const okMatch = trimmed.match(/FS_OK\s+(.+)$/i);
+  if (okMatch) {
+    const raw = okMatch[1].trim();
+    const num = Number(raw);
+    return Number.isFinite(num) ? num : raw;
+  }
+
+  const tailNum = trimmed.match(/(-?\d+)\s*$/);
+  if (tailNum) return Number(tailNum[1]);
+
+  return trimmed;
+}
+
+function clampInt(n, min, max) {
+  const v = Number.isFinite(n) ? Math.round(n) : min;
+  if (v < min) return min;
+  if (v > max) return max;
+  return v;
+}
+
+function toMsg(err) {
+  if (!err) return "";
+  if (err instanceof Error) return err.message;
+  return String(err);
+}

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "homebridge-frontier-silicon-plugin",
-  "version": "0.0.9",
-  "description": "Plugin for frontier silicon devices",
+  "version": "1.0.0",
+  "description": "Homebridge plugin for Frontier Silicon FSAPI devices, power and volume with safe polling",
   "license": "ISC",
+  "main": "index.js",
   "keywords": [
-    "homebridge-plugin"
+    "homebridge-plugin",
+    "homebridge",
+    "frontier",
+    "silicon",
+    "fsapi",
+    "internet-radio"
   ],
   "repository": {
     "type": "git",
@@ -17,7 +23,7 @@
     "name": "Boike Damhuis"
   },
   "engines": {
-    "node": ">=0.12.0",
-    "homebridge": ">=0.2.0"
+    "node": ">=18.0.0",
+    "homebridge": ">=1.6.0"
   }
 }