hoffmation-base 2.14.1 → 2.15.0

package/lib/index.js

@@ -63,6 +63,7 @@ class HoffmationBase {
             server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Asus Router settings detected --> initializing`);
             new server_1.AsusRouter(server_1.SettingsService.settings.asusConfig);
         }
+        server_1.Trilateration.initialize();
         server_1.TimeCallbackService.init();
         server_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Hoffmation-Base First Initializations finished`);
     }

package/lib/models/rooms/RoomBase.d.ts

@@ -1,5 +1,5 @@
 import { TimeCallback } from '../timeCallback';
-import { BaseGroup, DeviceCluster, GroupType, HeatGroup, LightGroup, PresenceGroup, SmokeGroup, SpeakerGroup, TasterGroup, WaterGroup, WindowGroup } from '../../server';
+import { BaseGroup, DeviceCluster, GroupType, HeatGroup, LightGroup, PresenceGroup, SmokeGroup, SpeakerGroup, TasterGroup, TrilaterationPoint, WaterGroup, WindowGroup } from '../../server';
 import { LogLevel } from '../logLevel';
 import { RoomSettingsController } from './RoomSettings';
 import { iRoomBase } from './iRoomBase';
@@ -10,7 +10,7 @@ export declare class RoomBase implements iRoomBase, iIdHolder {
     info: RoomInfo;
     skipNextRolloUp: boolean;
     settings: RoomSettingsController;
-    constructor(groupMap: Map<GroupType, BaseGroup>, roomName: string, etage?: number);
+    constructor(groupMap: Map<GroupType, BaseGroup>, roomName: string, etage?: number, startPoint?: TrilaterationPoint, endPoint?: TrilaterationPoint);
     get sonnenUntergangLichtCallback(): TimeCallback | undefined;
     get sonnenAufgangLichtCallback(): TimeCallback | undefined;
     get sunriseShutterCallback(): TimeCallback | undefined;

package/lib/models/rooms/RoomBase.js

@@ -11,13 +11,16 @@ const RoomSettings_1 = require("./RoomSettings");
 const roomInfo_1 = require("./roomInfo");
 const lodash_1 = __importDefault(require("lodash"));
 class RoomBase {
-    constructor(groupMap, roomName, etage = 99) {
+    constructor(groupMap, roomName, etage = 99, startPoint, endPoint) {
         this.groupMap = groupMap;
         this.skipNextRolloUp = false;
         this._deviceCluster = new server_1.DeviceCluster();
         this.info = new roomInfo_1.RoomInfo(roomName, etage);
         this.settings = new RoomSettings_1.RoomSettingsController(this);
         server_1.RoomService.addToRoomList(this);
+        if (startPoint && endPoint) {
+            server_1.Trilateration.addRoom(this, startPoint, endPoint);
+        }
     }
     get sonnenUntergangLichtCallback() {
         var _a;

package/lib/server/devices/baseDeviceInterfaces/iBluetoothDetector.d.ts

@@ -1,6 +1,7 @@
 import { iRoomDevice } from './iRoomDevice';
-import { ProximityCallback } from '../espresense';
+import { ProximityCallback, TrilaterationBasePoint } from '../espresense';
 export interface iBluetoothDetector extends iRoomDevice {
+    position?: TrilaterationBasePoint;
     /**
      * Add callback to react on a specified device entering/leaving a given zone
      * @param cb

package/lib/server/devices/espresense/detectedBluetoothDevice.d.ts

@@ -14,6 +14,7 @@ export declare class DetectedBluetoothDevice implements iBaseDevice {
     readonly deviceCapabilities: DeviceCapability[];
     deviceType: DeviceType;
     info: DeviceInfo;
+    lastRoom: string | undefined;
     constructor(id: string, settings?: iBluetoothTrackingSettings);
     get customName(): string;
     get name(): string;
@@ -27,4 +28,5 @@ export declare class DetectedBluetoothDevice implements iBaseDevice {
     private static deviceKeyBySettings;
     persistDeviceInfo(): void;
     loadDeviceSettings(): void;
+    guessRoom(): void;
 }

package/lib/server/devices/espresense/detectedBluetoothDevice.js

@@ -7,6 +7,8 @@ const deviceType_1 = require("../deviceType");
 const services_1 = require("../../services");
 const devices_1 = require("../devices");
 const trackedDistanceData_1 = require("./trackedDistanceData");
+const trilateration_1 = require("./trilateration");
+const trilaterationPointDistance_1 = require("./trilaterationPointDistance");
 class DetectedBluetoothDevice {
     constructor(id, settings) {
         this.id = id;
@@ -15,6 +17,7 @@ class DetectedBluetoothDevice {
         this.deviceCapabilities = [DeviceCapability_1.DeviceCapability.trackableDevice];
         this.deviceType = deviceType_1.DeviceType.TrackableDevice;
         this.info = new DeviceInfo_1.DeviceInfo();
+        this.lastRoom = undefined;
         if (settings === undefined) {
             return;
         }
@@ -98,5 +101,20 @@ class DetectedBluetoothDevice {
     loadDeviceSettings() {
         // Nothing
     }
+    guessRoom() {
+        const distances = [];
+        for (const key of this.distanceMap.keys()) {
+            const tracker = services_1.API.getDevice(key);
+            if (tracker === undefined || tracker.position === undefined) {
+                continue;
+            }
+            const distance = this.getDistance(key);
+            if ((distance === null || distance === void 0 ? void 0 : distance.distance) === undefined) {
+                continue;
+            }
+            distances.push(new trilaterationPointDistance_1.TrilaterationPointDistance(tracker.position.ownPoint.coordinateName, distance.distance));
+        }
+        this.lastRoom = trilateration_1.Trilateration.checkRoom(distances);
+    }
 }
 exports.DetectedBluetoothDevice = DetectedBluetoothDevice;

package/lib/server/devices/espresense/espresenseDevice.d.ts

@@ -6,14 +6,16 @@ import { DeviceInfo } from '../DeviceInfo';
 import { DeviceType } from '../deviceType';
 import { LogDebugType } from '../../services';
 import { ProximityCallback } from './proximityCallback';
+import { TrilaterationBasePoint } from './trilaterationBasePoint';
 export declare class EspresenseDevice implements iRoomDevice, iBluetoothDetector {
+    readonly position: TrilaterationBasePoint;
     settings: undefined;
     readonly deviceCapabilities: DeviceCapability[];
     deviceType: DeviceType;
     readonly name: string;
     private deviceMap;
     private proximityCallback;
-    constructor(name: string, roomName: string);
+    constructor(name: string, roomName: string, x: number, y: number, z: number);
     get customName(): string;
     protected _info: DeviceInfo;
     get info(): DeviceInfo;

package/lib/server/devices/espresense/espresenseDevice.js

@@ -9,13 +9,16 @@ const services_1 = require("../../services");
 const devices_1 = require("../devices");
 const detectedBluetoothDevice_1 = require("./detectedBluetoothDevice");
 const espresenseCoordinator_1 = require("./espresenseCoordinator");
+const trilaterationBasePoint_1 = require("./trilaterationBasePoint");
+const trilateration_1 = require("./trilateration");
 class EspresenseDevice {
-    constructor(name, roomName) {
+    constructor(name, roomName, x, y, z) {
         this.settings = undefined;
         this.deviceCapabilities = [DeviceCapability_1.DeviceCapability.bluetoothDetector];
         this.deviceType = deviceType_1.DeviceType.Espresense;
         this.deviceMap = new Map();
         this.proximityCallback = new Map();
+        this.position = new trilaterationBasePoint_1.TrilaterationBasePoint(x, y, z, roomName);
         this.name = name;
         this._info = new DeviceInfo_1.DeviceInfo();
         this._info.fullName = `Espresense ${roomName} ${name}`;
@@ -26,6 +29,7 @@ class EspresenseDevice {
         espresenseCoordinator_1.EspresenseCoordinator.addDevice(this, name);
         this.persistDeviceInfo();
         this.loadDeviceSettings();
+        trilateration_1.Trilateration.basePoints.push(this.position);
     }
     get customName() {
         return this.info.customName;
@@ -72,6 +76,7 @@ class EspresenseDevice {
             dev = this.addDeviceTracking(devName);
         }
         dev.updateDistance(this, data.distance);
+        dev.guessRoom();
         const cbs = this.proximityCallback.get(dev.name);
         if (cbs === undefined) {
             return;

package/lib/server/devices/espresense/index.d.ts

@@ -3,3 +3,8 @@ export * from './espresenseCoordinator';
 export * from './espresenseDevice';
 export * from './proximityCallback';
 export * from './trackedDistanceData';
+export * from './trilateration';
+export * from './trilaterationBasePoint';
+export * from './trilaterationRatedCoordinate';
+export * from './trilaterationPoint';
+export * from './trilaterationPointDistance';

package/lib/server/devices/espresense/index.js

@@ -19,3 +19,8 @@ __exportStar(require("./espresenseCoordinator"), exports);
 __exportStar(require("./espresenseDevice"), exports);
 __exportStar(require("./proximityCallback"), exports);
 __exportStar(require("./trackedDistanceData"), exports);
+__exportStar(require("./trilateration"), exports);
+__exportStar(require("./trilaterationBasePoint"), exports);
+__exportStar(require("./trilaterationRatedCoordinate"), exports);
+__exportStar(require("./trilaterationPoint"), exports);
+__exportStar(require("./trilaterationPointDistance"), exports);

package/lib/server/devices/espresense/trilateration.d.ts

@@ -0,0 +1,14 @@
+import { TrilaterationBasePoint } from './trilaterationBasePoint';
+import { TrilaterationPoint } from './trilaterationPoint';
+import { TrilaterationPointDistance } from './trilaterationPointDistance';
+import { RoomBase } from '../../../models';
+export declare class Trilateration {
+    static readonly basePoints: TrilaterationBasePoint[];
+    static possiblePoints: TrilaterationPoint[];
+    static addRoom(room: RoomBase, startPoint: TrilaterationPoint, endPoint: TrilaterationPoint): void;
+    static initialize(): void;
+    static getBestMatches(distances: TrilaterationPointDistance[]): TrilaterationPoint[];
+    private static getBestRatedCoordinates;
+    static checkRoom(distances: TrilaterationPointDistance[]): string | undefined;
+    private static getBestRatedCoordinatesFromMap;
+}

package/lib/server/devices/espresense/trilateration.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trilateration = void 0;
+const trilaterationPoint_1 = require("./trilaterationPoint");
+class Trilateration {
+    static addRoom(room, startPoint, endPoint) {
+        const points = trilaterationPoint_1.TrilaterationPoint.getPointsInRange(startPoint, endPoint, room.roomName);
+        this.possiblePoints.push(...points);
+    }
+    static initialize() {
+        for (const basePoint of this.basePoints) {
+            basePoint.fillMap(this.possiblePoints);
+        }
+    }
+    static getBestMatches(distances) {
+        const bestRatedCoordinates = this.getBestRatedCoordinates(distances);
+        if (bestRatedCoordinates.length === 0) {
+            return [];
+        }
+        const bestMatches = [];
+        for (const bestRatedCoordinate of bestRatedCoordinates) {
+            const point = this.possiblePoints.find((point) => point.coordinateName === bestRatedCoordinate.coordinateName);
+            if (point === undefined) {
+                continue;
+            }
+            bestMatches.push(point);
+        }
+        return bestMatches;
+    }
+    static getBestRatedCoordinates(distances) {
+        const allRatedCoordinates = new Map();
+        for (const dist of distances) {
+            const point = this.basePoints.find((basePoint) => basePoint.ownPoint.coordinateName === dist.pointName);
+            if (point === undefined) {
+                continue;
+            }
+            const ratedCoordinates = point.getRatedCoordinates(dist.distance);
+            for (const ratedCoordinate of ratedCoordinates) {
+                const existingCoordinate = allRatedCoordinates.get(ratedCoordinate.coordinateName);
+                if (existingCoordinate === undefined) {
+                    allRatedCoordinates.set(ratedCoordinate.coordinateName, ratedCoordinate);
+                    continue;
+                }
+                existingCoordinate.rating += ratedCoordinate.rating;
+                existingCoordinate.matchCount++;
+            }
+        }
+        return this.getBestRatedCoordinatesFromMap(allRatedCoordinates);
+    }
+    static checkRoom(distances) {
+        var _a;
+        const bestMatches = this.getBestMatches(distances);
+        if (bestMatches.length === 0) {
+            return undefined;
+        }
+        if (bestMatches.length === 1) {
+            return bestMatches[0].roomName;
+        }
+        // As we have multiple possible winners, we need to check how often which room occurs
+        const roomCount = new Map();
+        for (const point of bestMatches) {
+            const room = point.roomName;
+            const existingCount = (_a = roomCount.get(room)) !== null && _a !== void 0 ? _a : 0;
+            roomCount.set(room, existingCount + 1);
+        }
+        return Array.from(roomCount.entries()).sort((a, b) => b[1] - a[1])[0][0];
+    }
+    static getBestRatedCoordinatesFromMap(allRatedCoordinates) {
+        const sortedCoordinates = Array.from(allRatedCoordinates.values()).sort((a, b) => {
+            if (a.matchCount !== b.matchCount) {
+                return b.matchCount - a.matchCount;
+            }
+            return b.rating - a.rating;
+        });
+        const possibleWinner = [];
+        for (const coordinate of sortedCoordinates) {
+            if (possibleWinner.length === 0) {
+                possibleWinner.push(coordinate);
+                continue;
+            }
+            if (possibleWinner[0].rating !== coordinate.matchCount) {
+                break;
+            }
+            possibleWinner.push(coordinate);
+        }
+        return possibleWinner;
+    }
+}
+exports.Trilateration = Trilateration;
+Trilateration.basePoints = [];
+Trilateration.possiblePoints = [];

package/lib/server/devices/espresense/trilaterationBasePoint.d.ts

@@ -0,0 +1,15 @@
+import { TrilaterationRatedCoordinate } from './trilaterationRatedCoordinate';
+import { TrilaterationPoint } from './trilaterationPoint';
+export declare class TrilaterationBasePoint {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly roomName: string;
+    private readonly _maximumDistance;
+    readonly ownPoint: TrilaterationPoint;
+    readonly precalculatedDistances: Map<number, string[]>;
+    constructor(x: number, y: number, z: number, roomName: string, _maximumDistance?: number);
+    getRatedCoordinates(distance: number): TrilaterationRatedCoordinate[];
+    private rateCoordinates;
+    fillMap(points: TrilaterationPoint[]): void;
+}

package/lib/server/devices/espresense/trilaterationBasePoint.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrilaterationBasePoint = void 0;
+const trilaterationRatedCoordinate_1 = require("./trilaterationRatedCoordinate");
+const trilaterationPoint_1 = require("./trilaterationPoint");
+class TrilaterationBasePoint {
+    constructor(x, y, z, roomName, _maximumDistance = 8) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.roomName = roomName;
+        this._maximumDistance = _maximumDistance;
+        this.precalculatedDistances = new Map();
+        this.ownPoint = new trilaterationPoint_1.TrilaterationPoint(x, y, z, roomName);
+    }
+    getRatedCoordinates(distance) {
+        const result = [];
+        this.rateCoordinates(distance, result, 100);
+        this.rateCoordinates(distance - 0.5, result, 30);
+        this.rateCoordinates(distance + 0.5, result, 30);
+        this.rateCoordinates(distance + 1, result, 15);
+        this.rateCoordinates(distance - 1, result, 15);
+        this.rateCoordinates(distance + 1.5, result, 7.5);
+        this.rateCoordinates(distance - 1.5, result, 7.5);
+        return result;
+    }
+    rateCoordinates(distance, result, rating) {
+        const possiblePoints = this.precalculatedDistances.get(distance);
+        if (possiblePoints !== undefined) {
+            for (const point of possiblePoints) {
+                result.push(new trilaterationRatedCoordinate_1.TrilaterationRatedCoordinate(point, rating));
+            }
+        }
+    }
+    fillMap(points) {
+        var _a;
+        for (const point of points) {
+            const distance = point.getDot5Distance(this.ownPoint);
+            if (distance > this._maximumDistance) {
+                continue;
+            }
+            if (!this.precalculatedDistances.has(distance)) {
+                this.precalculatedDistances.set(distance, []);
+            }
+            (_a = this.precalculatedDistances.get(distance)) === null || _a === void 0 ? void 0 : _a.push(point.coordinateName);
+        }
+    }
+}
+exports.TrilaterationBasePoint = TrilaterationBasePoint;

package/lib/server/devices/espresense/trilaterationPoint.d.ts

@@ -0,0 +1,12 @@
+export declare class TrilaterationPoint {
+    x: number;
+    y: number;
+    z: number;
+    roomName: string;
+    matchPoints: number;
+    static getPointsInRange(a: TrilaterationPoint, b: TrilaterationPoint, roomName?: string): TrilaterationPoint[];
+    readonly coordinateName: string;
+    constructor(x: number, y: number, z: number, roomName: string, matchPoints?: number);
+    getDistance(other: TrilaterationPoint): number;
+    getDot5Distance(other: TrilaterationPoint): number;
+}

package/lib/server/devices/espresense/trilaterationPoint.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrilaterationPoint = void 0;
+const services_1 = require("../../services");
+class TrilaterationPoint {
+    static getPointsInRange(a, b, roomName = '') {
+        const points = [];
+        if (a.x > b.x || a.y > b.y || a.z > b.z) {
+            throw new Error('Room Coordinates are not in order left-front-bottom to right-back-top');
+        }
+        for (let x = a.x; x <= b.x; x++) {
+            for (let y = a.y; y <= b.y; y++) {
+                for (let z = a.z; z <= b.z; z++) {
+                    points.push(new TrilaterationPoint(x, y, z, roomName));
+                }
+            }
+        }
+        return points;
+    }
+    constructor(x, y, z, roomName, matchPoints = 0) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.roomName = roomName;
+        this.matchPoints = matchPoints;
+        this.coordinateName = `${this.x}-${this.y}-${this.z}`;
+    }
+    getDistance(other) {
+        return Math.sqrt((this.x - other.x) ** 2 + (this.y - other.y) ** 2 + (this.z - other.z) ** 2);
+    }
+    getDot5Distance(other) {
+        return services_1.Utils.roundDot5(this.getDistance(other));
+    }
+}
+exports.TrilaterationPoint = TrilaterationPoint;

package/lib/server/devices/espresense/trilaterationPointDistance.d.ts

@@ -0,0 +1,5 @@
+export declare class TrilaterationPointDistance {
+    readonly pointName: string;
+    readonly distance: number;
+    constructor(pointName: string, distance: number);
+}

package/lib/server/devices/espresense/trilaterationPointDistance.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrilaterationPointDistance = void 0;
+class TrilaterationPointDistance {
+    constructor(pointName, distance) {
+        this.pointName = pointName;
+        this.distance = distance;
+    }
+}
+exports.TrilaterationPointDistance = TrilaterationPointDistance;

package/lib/server/devices/espresense/trilaterationRatedCoordinate.d.ts

@@ -0,0 +1,6 @@
+export declare class TrilaterationRatedCoordinate {
+    coordinateName: string;
+    rating: number;
+    matchCount: number;
+    constructor(coordinateName: string, rating: number, matchCount?: number);
+}

package/lib/server/devices/espresense/trilaterationRatedCoordinate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrilaterationRatedCoordinate = void 0;
+class TrilaterationRatedCoordinate {
+    constructor(coordinateName, rating, matchCount = 1) {
+        this.coordinateName = coordinateName;
+        this.rating = rating;
+        this.matchCount = matchCount;
+    }
+}
+exports.TrilaterationRatedCoordinate = TrilaterationRatedCoordinate;

package/lib/server/services/utils/utils.d.ts

@@ -21,6 +21,7 @@ export declare class Utils {
     static testInitializeServices(): void;
     static kWh(wattage: number, durationInMs: number): number;
     static round(number: number, digits: number): number;
+    static roundDot5(number: number): number;
     static beetweenDays(date: Date, startDay: number, endDay: number): boolean;
     static nowTime(): {
         hours: number;

package/lib/server/services/utils/utils.js

@@ -135,6 +135,11 @@ class Utils {
         const factor = Math.pow(10, digits);
         return Math.round(number * factor) / factor;
     }
+    static roundDot5(number) {
+        const x = Math.round(number * 10);
+        const roundToClosest5 = x % 5 >= 2.5 ? Math.floor(x / 5) * 5 + 5 : Math.floor(x / 5) * 5;
+        return roundToClosest5 / 10;
+    }
     static beetweenDays(date, startDay, endDay) {
         const yearStart = new Date(date.getTime());
         yearStart.setMonth(0, 1);