hoffmation-base 0.1.14 → 0.1.18

package/server/devices/hmIPDevices/hmIpHeizgruppe.ts

@@ -1,172 +0,0 @@
-import { LogLevel } from '../../../models/logLevel';
-import { HmIPDevice } from './hmIpDevice';
-import { HmIpDeviceType } from './hmIpDeviceType';
-import { DeviceInfo } from '../DeviceInfo';
-import { ServerLogService } from '../../services/log-service';
-import { TemperaturSettings } from '../../../models/temperaturSettings';
-import { Persist } from '../../services/dbo/persist';
-import { HmIpHeizung } from './hmIpHeizung';
-import { Devices } from '../devices';
-import { Utils } from '../../services/utils/utils';
-
-export class HmIpHeizgruppe extends HmIPDevice {
-  private _automaticMode: boolean = true;
-  private _iAutomaticInterval: NodeJS.Timeout;
-  private _level: number = 0;
-  private _temperatur: number = 0;
-  private _humidity: number = 0;
-  private _desiredTemperatur: number = 0;
-  private _setPointTemperaturID: string = '';
-  private _automaticFallBackTemperatur: number = 20;
-  private _automaticPoints: { [name: string]: TemperaturSettings } = {};
-  private _humidityCallbacks: Array<(pValue: number) => void> = [];
-
-  public constructor(pInfo: DeviceInfo) {
-    super(pInfo, HmIpDeviceType.HmIpHeizgruppe);
-    this._setPointTemperaturID = `${this.info.fullID}.1.SET_POINT_TEMPERATURE`;
-    this._iAutomaticInterval = Utils.guardedInterval(this.checkAutomaticChange, 300000, this); // Alle 5 Minuten prüfen
-  }
-
-  public get sLevel(): string {
-    return `${this._level * 100}%`;
-  }
-
-  public get iLevel(): number {
-    return this._level;
-  }
-
-  public get sTemperatur(): string {
-    return `${this._temperatur}°C`;
-  }
-
-  public get iTemperatur(): number {
-    return this._temperatur;
-  }
-
-  public get desiredTemperatur(): number {
-    return this._desiredTemperatur;
-  }
-
-  public get humidity(): number {
-    return this._humidity;
-  }
-
-  private set humidity(val: number) {
-    this._humidity = val;
-    for (const cb of this._humidityCallbacks) {
-      cb(val);
-    }
-  }
-
-  public set desiredTemperatur(val: number) {
-    if (!this.ioConn) {
-      ServerLogService.writeLog(LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
-      return;
-    }
-
-    ServerLogService.writeLog(LogLevel.Info, `Neue Temperatur (${val}) für "${this.info.customName}".`);
-    this.ioConn.setState(this._setPointTemperaturID, val, (err) => {
-      if (err) {
-        ServerLogService.writeLog(
-          LogLevel.Error,
-          `Temperaturänderung für "${this.info.customName}" ergab Fehler ${err}.`,
-        );
-      } else {
-        ServerLogService.writeLog(
-          LogLevel.Debug,
-          `Temperaturänderung für "${this.info.customName}" auf ${val} erfolgreich`,
-        );
-      }
-    });
-  }
-
-  public addHumidityCallback(pCallback: (pValue: number) => void): void {
-    this._humidityCallbacks.push(pCallback);
-    if (this._humidity > 0) {
-      pCallback(this._humidity);
-    }
-  }
-
-  public deleteAutomaticPoint(name: string): void {
-    if (this._automaticPoints[name] !== undefined) delete this._automaticPoints[name];
-  }
-
-  public getBelongingHeizungen(): HmIpHeizung[] {
-    const result: HmIpHeizung[] = [];
-    for (const dID in Devices.hmIP) {
-      const d = Devices.hmIP[dID];
-      if (d.deviceType === HmIpDeviceType.HmIpHeizung && d.info.room === this.info.room) {
-        result.push(d as HmIpHeizung);
-      }
-    }
-    return result;
-  }
-
-  public setAutomaticPoint(name: string, setting: TemperaturSettings): void {
-    this._automaticPoints[name] = setting;
-  }
-
-  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
-    ServerLogService.writeLog(
-      LogLevel.Trace,
-      `Heizgruppe "${this.info.customName}" Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`,
-    );
-    super.update(idSplit, state, initial, true);
-
-    switch (idSplit[3]) {
-      case '1':
-        this.updateBaseInformation(idSplit[4], state, initial);
-        break;
-    }
-  }
-
-  private updateBaseInformation(name: string, state: ioBroker.State, initial: boolean) {
-    switch (name) {
-      case 'ACTUAL_TEMPERATURE':
-        this._temperatur = state.val as number;
-        break;
-      case 'LEVEL':
-        this._level = state.val as number;
-        break;
-      case 'HUMIDITY':
-        this.humidity = state.val as number;
-        break;
-      case 'SET_POINT_TEMPERATURE':
-        ServerLogService.writeLog(
-          LogLevel.Trace,
-          `Heizgruppe "${this.info.customName}" Update Soll-Temperatur JSON: ${JSON.stringify(state)}`,
-        );
-        this._desiredTemperatur = state.val as number;
-        break;
-    }
-  }
-
-  private checkAutomaticChange(): void {
-    if (!this._automaticMode) {
-      Persist.addTemperaturDataPoint(this);
-      return;
-    }
-
-    for (const name in this._automaticPoints) {
-      if (this._automaticPoints[name] === undefined) {
-        continue;
-      }
-
-      const settings: TemperaturSettings = this._automaticPoints[name];
-      if (!settings.isNowInRange()) {
-        continue;
-      }
-
-      if (this._desiredTemperatur !== settings.temperatur) {
-        ServerLogService.writeLog(
-          LogLevel.Debug,
-          `Automatische Temperaturanpassung für ${this.info.customName} auf ${settings.temperatur}°C`,
-        );
-        this.desiredTemperatur = settings.temperatur;
-      }
-      break;
-    }
-
-    Persist.addTemperaturDataPoint(this);
-  }
-}

package/server/devices/hmIPDevices/hmIpHeizung.ts

@@ -1,69 +0,0 @@
-import { LogLevel } from '../../../models/logLevel';
-import { ServerLogService } from '../../services/log-service';
-import { HmIPDevice } from './hmIpDevice';
-import { HmIpDeviceType } from './hmIpDeviceType';
-import { DeviceInfo } from '../DeviceInfo';
-
-export class HmIpHeizung extends HmIPDevice {
-  private _temperatur: number = 0;
-  private _level: number = 0;
-  private _adaptionState: number | undefined;
-  private _desiredTemperatur: number = 0;
-
-  public get desiredTemperatur(): number {
-    return this._desiredTemperatur;
-  }
-
-  public get iLevel(): number {
-    return this._level;
-  }
-
-  public get iTemperatur(): number {
-    return this._temperatur;
-  }
-
-  public constructor(pInfo: DeviceInfo) {
-    super(pInfo, HmIpDeviceType.HmIpHeizung);
-  }
-
-  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
-    ServerLogService.writeLog(
-      LogLevel.Trace,
-      `Heizung "${this.info.customName}" Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`,
-    );
-    super.update(idSplit, state, initial, true);
-
-    switch (idSplit[3]) {
-      case '1':
-        this.updateBaseInformation(idSplit[4], state, initial);
-        break;
-    }
-  }
-
-  private updateBaseInformation(name: string, state: ioBroker.State, initial: boolean) {
-    switch (name) {
-      case 'ACTUAL_TEMPERATURE':
-        this._temperatur = state.val as number;
-        break;
-      case 'LEVEL':
-        this._level = state.val as number;
-        break;
-      case 'VALVE_STATE':
-        this._adaptionState = state.val as number;
-        if (this._adaptionState !== 4) {
-          ServerLogService.writeLog(
-            LogLevel.Alert,
-            `Adaption State für Heizung "${this.info.customName}" ungewöhnlich: ${this._adaptionState}`,
-          );
-        }
-        break;
-      case 'SET_POINT_TEMPERATURE':
-        ServerLogService.writeLog(
-          LogLevel.Trace,
-          `Heizung "${this.info.customName}" Update Soll-Temperatur JSON: ${JSON.stringify(state)}`,
-        );
-        this._desiredTemperatur = state.val as number;
-        break;
-    }
-  }
-}

package/server/devices/hmIPDevices/hmIpLampe.ts

@@ -1,120 +0,0 @@
-import { LogLevel } from '../../../models/logLevel';
-import { HmIPDevice } from './hmIpDevice';
-import { HmIpDeviceType } from './hmIpDeviceType';
-import { DeviceInfo } from '../DeviceInfo';
-import { ServerLogService } from '../../services/log-service';
-import { ActuatorSettings } from '../../../models/actuatorSettings';
-import { Utils } from '../../services/utils/utils';
-import { iLamp } from '../iLamp';
-
-export class HmIpLampe extends HmIPDevice implements iLamp {
-  public lightOn: boolean = false;
-  public queuedLightValue: boolean | null = null;
-  public isStromStoss: boolean = false;
-  public settings: ActuatorSettings = new ActuatorSettings();
-  private lightOnSwitchID: string = '';
-  private turnOffTimeout: NodeJS.Timeout | undefined = undefined;
-  private turnOffTime: number = 0;
-
-  public constructor(pInfo: DeviceInfo) {
-    super(pInfo, HmIpDeviceType.HmIpLampe);
-    this.lightOnSwitchID = `${this.info.fullID}.2.STATE`;
-  }
-
-  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
-    ServerLogService.writeLog(
-      LogLevel.DeepTrace,
-      `Lampen Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`,
-    );
-    super.update(idSplit, state, initial, true);
-    this.queuedLightValue = null;
-    switch (idSplit[3]) {
-      case '1':
-        if (idSplit[4] === 'STATE') {
-          this.lightOn = state.val as boolean;
-        }
-        break;
-    }
-  }
-
-  /**
-   * This function thats the light to a specific value
-   * @param pValue The desired value
-   * @param timeout A chosen Timeout after which the light should be reset
-   */
-  public setLight(pValue: boolean, timeout: number = -1, force: boolean = false): void {
-    if (!force && pValue === this.lightOn && this.queuedLightValue === null) {
-      ServerLogService.writeLog(
-        LogLevel.DeepTrace,
-        `Skip light command for "${this.info.customName}" as it is already ${pValue}`,
-      );
-      return;
-    }
-    if (this.lightOnSwitchID === '') {
-      ServerLogService.writeLog(LogLevel.Error, `Keine Switch ID für "${this.info.customName}" bekannt.`);
-      return;
-    }
-
-    if (!this.ioConn) {
-      ServerLogService.writeLog(LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
-      return;
-    }
-
-    if (!force && Utils.nowMS() < this.turnOffTime) {
-      ServerLogService.writeLog(
-        LogLevel.Debug,
-        `Skip automatic command for "${this.info.customName}" to ${pValue} as it is locked until ${new Date(
-          this.turnOffTime,
-        ).toLocaleString()}`,
-      );
-      return;
-    }
-
-    ServerLogService.writeLog(LogLevel.Debug, `Lampe schalten: "${this.info.customName}" Wert: ${pValue}`);
-    this.ioConn.setState(this.lightOnSwitchID, pValue, (err) => {
-      if (err) {
-        ServerLogService.writeLog(LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
-      }
-    });
-    this.queuedLightValue = pValue;
-
-    if (this.isStromStoss) {
-      timeout = 5000;
-    }
-
-    if (this.turnOffTimeout !== undefined) {
-      clearTimeout(this.turnOffTimeout);
-      this.turnOffTimeout = undefined;
-    }
-
-    if (timeout < 0 || !pValue) {
-      return;
-    }
-
-    this.turnOffTime = Utils.nowMS() + timeout;
-    this.turnOffTimeout = Utils.guardedTimeout(
-      () => {
-        ServerLogService.writeLog(LogLevel.Debug, `Delayed Turnoff for "${this.info.customName}" initiated`);
-        this.turnOffTimeout = undefined;
-        if (!this.room) {
-          this.setLight(false, -1, true);
-        } else {
-          this.room.setLightTimeBased(true);
-        }
-      },
-      timeout,
-      this,
-    );
-  }
-
-  /**
-   * Switch the current condition of the light
-   * @param force Whether this is a forcing action skipping delays and locks
-   */
-  public toggleLight(force: boolean = false): boolean {
-    const newVal = this.queuedLightValue !== null ? !this.queuedLightValue : !this.lightOn;
-    const timeout: number = newVal && force ? 30 * 60 * 1000 : -1;
-    this.setLight(newVal, timeout, force);
-    return newVal;
-  }
-}

package/server/devices/hmIPDevices/hmIpPraezenz.ts

@@ -1,117 +0,0 @@
-import { HmIPDevice } from './hmIpDevice';
-import { HmIpDeviceType } from './hmIpDeviceType';
-import { DeviceInfo } from '../DeviceInfo';
-import { LogLevel } from '../../../models/logLevel';
-import { ServerLogService } from '../../services/log-service';
-import { Persist } from '../../services/dbo/persist';
-import { CountToday } from '../../../models/persistence/todaysCount';
-import { Utils } from '../../services/utils/utils';
-import { CurrentIlluminationDataPoint } from '../../../models/persistence/CurrentIlluminationDataPoint';
-import { iIlluminationSensor } from '../iIlluminationSensor';
-
-export class HmIpPraezenz extends HmIPDevice implements iIlluminationSensor {
-  public excludeFromNightAlarm: boolean = false;
-  public presenceDetected: boolean = false;
-  private _detectionsToday: number = 0;
-  private _presenceDetectedCallback: Array<(pValue: boolean) => void> = [];
-  private static PRESENCE_DETECTION: string = 'PRESENCE_DETECTION_STATE';
-  private static ILLUMINATION_DURING_MOVEMENT: string = 'CURRENT_ILLUMINATION';
-  private static CURRENT_ILLUMINATION: string = 'ILLUMINATION';
-  private presenceStateID: string;
-  private initialized: boolean = false;
-  private _currentIllumination: number = -1;
-
-  public get detectionsToday(): number {
-    return this._detectionsToday;
-  }
-
-  public set detectionsToday(pVal: number) {
-    const oldVal: number = this._detectionsToday;
-    this._detectionsToday = pVal;
-    Persist.persistTodayCount(this, pVal, oldVal);
-  }
-
-  public get currentIllumination(): number {
-    return this._currentIllumination;
-  }
-  private set currentIllumination(value: number) {
-    this._currentIllumination = value;
-    Persist.persistCurrentIllumination(
-      new CurrentIlluminationDataPoint(this.info.room, this.info.devID, value, new Date(), this.room?.LampenGroup.anyLightsOwn())
-    );
-  }
-
-  public constructor(pInfo: DeviceInfo) {
-    super(pInfo, HmIpDeviceType.HmIpPraezenz);
-    this.presenceStateID = `${this.info.fullID}.1.${HmIpPraezenz.PRESENCE_DETECTION}`;
-    Persist.getCount(this).then((todayCount: CountToday) => {
-      this.detectionsToday = todayCount.counter;
-      ServerLogService.writeLog(
-        LogLevel.Debug,
-        `Präsenzcounter "${this.info.customName}" vorinitialisiert mit ${this.detectionsToday}`,
-      );
-      this.initialized = true;
-    });
-  }
-
-  public addPresenceCallback(pCallback: (pValue: boolean) => void): void {
-    this._presenceDetectedCallback.push(pCallback);
-  }
-
-  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
-    ServerLogService.writeLog(LogLevel.Trace, `Präzens Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
-    super.update(idSplit, state, initial, true);
-
-    if (idSplit[3] !== '1') {
-      // Nur die Infos in Kanal 1 sind relevant
-      return;
-    }
-
-    switch (idSplit[4]) {
-      case HmIpPraezenz.PRESENCE_DETECTION:
-        this.updatePresence(state.val as boolean);
-        break;
-      case HmIpPraezenz.CURRENT_ILLUMINATION:
-        this.currentIllumination = state.val as number;
-        break;
-    }
-  }
-
-  public updatePresence(pVal: boolean): void {
-    if (!this.initialized && pVal) {
-      ServerLogService.writeLog(
-        LogLevel.Debug,
-        `Präsenz für "${this.info.customName}" erkannt aber die Initialisierung aus der DB ist noch nicht erfolgt --> verzögern`,
-      );
-      Utils.guardedTimeout(
-        () => {
-          this.updatePresence(pVal);
-        },
-        1000,
-        this,
-      );
-      return;
-    }
-    if (pVal === this.presenceDetected) {
-      ServerLogService.writeLog(
-        LogLevel.Debug,
-        `Überspringe Präsenz für "${this.info.customName}" da bereits der Wert ${pVal} vorliegt`,
-      );
-      return;
-    }
-
-    this.presenceDetected = pVal;
-    ServerLogService.writeLog(LogLevel.Debug, `Neuer Präsenzstatus Wert für "${this.info.customName}": ${pVal}`);
-
-    if (pVal) {
-      this.detectionsToday++;
-      ServerLogService.writeLog(
-        LogLevel.Trace,
-        `Dies ist die ${this.detectionsToday} Bewegung für "${this.info.customName}"`,
-      );
-    }
-    for (const c of this._presenceDetectedCallback) {
-      c(pVal);
-    }
-  }
-}

package/server/devices/hmIPDevices/hmIpRoll.ts

@@ -1,133 +0,0 @@
-import { LogLevel } from '../../../models/logLevel';
-import { Fenster } from './Fenster';
-import { FensterPosition } from './FensterPosition';
-import { HmIPDevice } from './hmIpDevice';
-import { HmIpDeviceType } from './hmIpDeviceType';
-import { DeviceInfo } from '../DeviceInfo';
-import { ServerLogService } from '../../services/log-service';
-import { Utils } from '../../services/utils/utils';
-
-export class HmIpRoll extends HmIPDevice {
-  public get currentLevel(): number {
-    if (this._setLevel !== -1 && this._currentLevel !== this._setLevel) {
-      return this._setLevel;
-    }
-    return this._currentLevel;
-  }
-
-  public set currentLevel(value: number) {
-    if (value !== this._setLevel && Utils.nowMS() - this._setLevelTime < 60 * 10000) {
-      value = this._setLevel;
-    }
-    if (value !== this._currentLevel && this._fenster) {
-      Utils.guardedNewThread(() => {
-        this._fenster?.rolloPositionChange(value);
-      }, this);
-    }
-    this._currentLevel = value;
-  }
-
-  public get desiredFensterLevel(): number {
-    if (this._fenster === undefined) {
-      return -1;
-    }
-    return this._fenster.desiredPosition;
-  }
-
-  private _currentLevel: number = -1;
-  private _setLevelSwitchID: string;
-  private _fenster?: Fenster;
-  private _firstCommandRecieved: boolean = false;
-  private _setLevel: number = -1;
-  private _setLevelTime: number = -1;
-
-  public set Fenster(value: Fenster) {
-    this._fenster = value;
-  }
-
-  public constructor(pInfo: DeviceInfo) {
-    super(pInfo, HmIpDeviceType.HmIpRoll);
-    this._setLevelSwitchID = `${this.info.fullID}.4.LEVEL`;
-  }
-
-  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
-    ServerLogService.writeLog(
-      LogLevel.DeepTrace,
-      `Rollo Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`,
-    );
-    super.update(idSplit, state, initial, true);
-    switch (idSplit[3]) {
-      case '3':
-        if (idSplit[4] === 'LEVEL') {
-          this.currentLevel = state.val as number;
-        }
-        break;
-    }
-  }
-
-  public setLevel(pPosition: number, initial: boolean = false, skipOpenWarning: boolean = false): void {
-    if (!this._firstCommandRecieved && !initial) {
-      this._firstCommandRecieved = true;
-    }
-    if (this._firstCommandRecieved && initial) {
-      ServerLogService.writeLog(
-        LogLevel.Debug,
-        `Skipped initial Rollo "${this.info.customName}" to ${pPosition} as we recieved a command already`,
-      );
-      return;
-    }
-    if (this.currentLevel === pPosition) {
-      ServerLogService.writeLog(
-        LogLevel.Debug,
-        `Skip Rollo command for "${this.info.customName}" to Position ${pPosition} as this is the current one`,
-      );
-      return;
-    }
-    if (this._setLevelSwitchID === '') {
-      console.error(`Keine Switch ID für "${this.info.customName}" bekannt.`);
-      return;
-    }
-
-    if (!this.ioConn) {
-      console.error(`Keine Connection für "${this.info.customName}" bekannt.`);
-      return;
-    }
-
-    if (this._fenster !== undefined) {
-      if (this._fenster.griffeInPosition(FensterPosition.offen) > 0 && pPosition < 100) {
-        if (!skipOpenWarning) {
-          ServerLogService.writeLog(
-            LogLevel.Alert,
-            `Fahre Rollo "${this.info.customName}" nicht runter, weil das Fenster offen ist!`,
-          );
-        }
-        return;
-      }
-      if (this._fenster.griffeInPosition(FensterPosition.kipp) > 0 && pPosition < 50) {
-        pPosition = 50;
-        if (!skipOpenWarning) {
-          ServerLogService.writeLog(
-            LogLevel.Alert,
-            `Fahre Rollo "${this.info.customName}" nicht runter, weil das Fenster auf Kipp ist!`,
-          );
-        }
-      }
-    }
-
-    this._setLevel = pPosition;
-    ServerLogService.writeLog(LogLevel.Debug, `Fahre Rollo "${this.info.customName}" auf Position ${pPosition}`);
-    this.ioConn.setState(this._setLevelSwitchID, pPosition);
-  }
-
-  public down(initial: boolean = false): void {
-    this.setLevel(0, initial);
-  }
-
-  public middle(): void {
-    this.setLevel(50);
-  }
-
-  public up(initial: boolean = false): void {
-    this.setLevel(100, initial);
-  }
-}

package/server/devices/hmIPDevices/hmIpTaster.ts

@@ -1,82 +0,0 @@
-import { HmIPDevice } from './hmIpDevice';
-import { HmIpDeviceType } from './hmIpDeviceType';
-import { DeviceInfo } from '../DeviceInfo';
-import { Taste } from '../taste';
-import { LogLevel } from '../../../models/logLevel';
-import { ServerLogService } from '../../services/log-service';
-import { iTaster } from "/server/config/private/server/devices/iTaster";
-
-export class HmIpTaster extends HmIPDevice implements iTaster{
-  public tasten: { [id: string]: Taste} = {
-    ObenLinks: new Taste(1),
-    ObenRechts: new Taste(2),
-    MitteLinks: new Taste(3),
-    MitteRechts: new Taste(4),
-    UntenLinks: new Taste(5),
-    UntenRechts: new Taste(6),
-  };
-
-  public constructor(pInfo: DeviceInfo) {
-    super(pInfo, HmIpDeviceType.HmIpTaster);
-  }
-
-  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
-    ServerLogService.writeLog(LogLevel.Trace, `Taster Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
-    super.update(idSplit, state, initial, true);
-    let cTaste: Taste | undefined = undefined;
-    switch (idSplit[3]) {
-      case '1':
-        cTaste = this.tasten.ObenLinks;
-        break;
-      case '2':
-        cTaste = this.tasten.ObenRechts;
-        break;
-      case '3':
-        cTaste = this.tasten.MitteLinks;
-        break;
-      case '4':
-        cTaste = this.tasten.MitteRechts;
-        break;
-      case '5':
-        cTaste = this.tasten.UntenLinks;
-        break;
-      case '6':
-        cTaste = this.tasten.UntenRechts;
-        break;
-    }
-
-    if (cTaste === undefined) {
-      return;
-    }
-
-    switch (idSplit[4]) {
-      case 'PRESS_SHORT':
-        if (!initial) {
-          // Tasten beim Starten ignorieren
-          cTaste.updateShort(state.val as boolean);
-        }
-        break;
-      case 'PRESS_LONG':
-        if (!initial) {
-          // Tasten beim Starten ignorieren
-          cTaste.updateLong(state.val as boolean);
-        }
-        break;
-    }
-  }
-
-  public getTastenAssignment(): string {
-    const result: string[] = [`Button: ${this.info.customName}`];
-    for (const tastenName in this.tasten) {
-      const desc: string =  this.tasten[tastenName].getDescription();
-      if (desc === '') {
-        continue;
-      }
-      result.push(`Button "${tastenName}":`);
-      result.push(desc);
-      result.push('');
-    }
-    result.push('____________');
-    return result.join('\n');
-  }
-}