isy-nodejs 0.5.0-beta.9 → 1.0.1-alpha.1

package/src/Devices/Insteon/InsteonDimmableDevice.ts

@@ -1,16 +1,59 @@
-import { ISY } from '../../ISY';
-import { ISYLevelDevice } from '../ISYDevice';
-import { InsteonRelayDevice } from './InsteonRelayDevice';
+import { Identity } from '@project-chip/matter.js/util';
+import { ISY } from '../../ISY.js';
+import { MapsTo, type MapsToCluster } from '../MapsTo.js';
+import { EndpointFor } from '../EndpointFor.js';
+import { InsteonRelayDevice } from './InsteonRelayDevice.js';
+//
+import type { DimmableLightRequirements } from '@project-chip/matter.js/devices/DimmableLightDevice';
+import { ClusterBehavior } from '@project-chip/matter.js/behavior/cluster';
+import { OnOffBehavior as OOB, OnOffInterface } from '@project-chip/matter.js/behaviors/on-off';
+import { OnOff, ClusterType } from '@project-chip/matter.js/cluster';
+import 'winston';
+import { UnitOfMeasure } from '../../Definitions/Global/UOM.js';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
 
-export class InsteonDimmableDevice extends ISYLevelDevice(InsteonRelayDevice) {
-	constructor (isy: ISY, node: any) {
+// #region Type aliases (2)
+
+type LevelControlBehavior = typeof DimmableLightRequirements.LevelControlServer;
+type OnOffBehavior = typeof OOB;
+
+// #endregion Type aliases (2)
+
+// #region Classes (1)
+
+//@ts-ignore
+export class InsteonDimmableDevice extends InsteonRelayDevice implements MapsTo<LevelControlBehavior, OnOffBehavior> {
+	// #region Constructors (1)
+
+	constructor(isy: ISY, node: NodeInfo) {
 		super(isy, node);
 		this.isDimmable = true;
 	}
-	get brightnessLevel() {
-		return this.level;
-	}
-	public async updateBrightnessLevel(level: number): Promise<{}> {
-		return super.updateLevel(level);
+
+	// #endregion Constructors (1)
+
+	// #region Public Methods (1)
+
+	// public async updateBrightnessLevel(level: number): Promise<{}> {
+	// 	return super.(level);
+	// }
+	public override async initialize(endpoint: EndpointFor<LevelControlBehavior, OnOffBehavior>): Promise<void> {
+		try {
+			await super.initialize(endpoint);
+			const that = this;
+			// endpoint.events.levelControl.onLevel$Changed.on((value) => that.updateLevel(that.convertFrom(value, UnitOfMeasure.LevelFrom0To255)));
+
+			// endpoint.set({levelControl: {onLevel: this.convertTo(this.level,UnitOfMeasure.LevelFrom0To255)}});
+
+			// this.on("PropertyChanged", (p,n,o,f) => endpoint.set({levelControl: {onLevel: that.convertTo(Number(n),UnitOfMeasure.LevelFrom0To255)}})
+			// );
+
+			// //endpoint.events.levelCont
+			// endpoint.events.levelControl.maxLevel$Changed.on((value) => that.sendCommand("OL",value));
+		} catch (error) {}
 	}
+
+	// #endregion Public Methods (1)
 }
+
+// #endregion Classes (1)

package/src/Devices/Insteon/InsteonDimmerOutletDevice.ts

@@ -1,7 +1,9 @@
-import { InsteonDimmableDevice } from './InsteonDimmableDevice';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import type { ISY } from '../../ISY.js';
+import { InsteonDimmableDevice } from './InsteonDimmableDevice.js';
 
 export class InsteonDimmerOutletDevice extends InsteonDimmableDevice {
-	constructor (isy: any, deviceNode: any) {
+	constructor (isy: ISY, deviceNode: NodeInfo) {
 		super(isy, deviceNode);
 	}
 }

package/src/Devices/Insteon/InsteonDimmerSwitchDevice.ts

@@ -1,8 +1,11 @@
-import { InsteonSwitchDevice } from './InsteonDevice';
-import { InsteonDimmableDevice } from './InsteonDimmableDevice';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import type { ISY } from '../../ISY.js';
 
-export class InsteonDimmerSwitchDevice extends InsteonSwitchDevice(InsteonDimmableDevice) {
-	constructor (isy: any, deviceNode: any) {
+import { InsteonDimmableDevice } from './InsteonDimmableDevice.js';
+import 'winston';
+
+export class InsteonDimmerSwitchDevice extends InsteonDimmableDevice {
+	constructor (isy: ISY, deviceNode: NodeInfo) {
 		super(isy, deviceNode);
 	}
 }

package/src/Devices/Insteon/InsteonDoorWindowSensorDevice.ts

@@ -1,14 +1,18 @@
-import { ISY } from '../../ISY';
-import { ISYBinaryStateDevice } from '../ISYDevice';
-import { InsteonBaseDevice } from './InsteonBaseDevice';
-
-export class InsteonDoorWindowSensorDevice extends ISYBinaryStateDevice(InsteonBaseDevice) {
-	constructor (isy: ISY, deviceNode: {
-		type: string;
-	}) {
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import { ISY } from '../../ISY.js';
+import { ISYBinaryStateDevice } from '../ISYDevice.js';
+import { InsteonBaseDevice } from './InsteonBaseDevice.js';
+import 'winston';
+
+export class InsteonDoorWindowSensorDevice extends InsteonBaseDevice {
+
+
+	constructor (isy: ISY, deviceNode: NodeInfo) {
 		super(isy, deviceNode);
+
+
 	}
 	get isOpen() {
-		return this.state;
+		return this.drivers.ST.value === 0;
 	}
 }

package/src/Devices/Insteon/InsteonFanDevice.ts

@@ -1,75 +1,70 @@
-import { Family } from '../../Families';
-import { ISY, ISYNode } from '../../ISY';
-import { States } from '../../ISYConstants';
-import { ISYBinaryStateDevice, ISYDevice, ISYLevelDevice } from '../ISYDevice';
-import { InsteonBaseDevice } from './InsteonBaseDevice';
-import { InsteonDimmableDevice } from './InsteonDimmableDevice';
+import { Family } from '../../Definitions/Global/Families.js';
+import { ISY, ISYNode } from '../../ISY.js';
+import { States } from '../../ISYConstants.js';
 
-export class InsteonFanMotorDevice extends ISYLevelDevice(ISYBinaryStateDevice(InsteonBaseDevice)) {
-		constructor(isy: ISY, deviceNode: {
-				type: string;
-		}) {
-				super(isy, deviceNode);
-				this.hidden = true;
-		}
+import { InsteonBaseDevice } from './InsteonBaseDevice.js';
+import { InsteonDimmableDevice } from './InsteonDimmableDevice.js';
+import 'winston';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import {Insteon} from './index.js';
 
-		get isOn() {
-				return this.state;
-		}
-		get fanSpeed() {
-				return this.level;
-		}
+export class InsteonFanMotorDevice extends InsteonBaseDevice {
+	constructor (isy: ISY, deviceNode: NodeInfo) {
+		super(isy, deviceNode);
+		this.hidden = true;
+	}
 
-		public async updateFanSpeed(level: number) {
-				return this.updateLevel(level);
-		}
-		public async updateIsOn(isOn: boolean) {
-				if (!isOn) {
-						this.updateLevel(States.Level.Min);
-				} else {
-						this.updateLevel(States.Level.Max);
-				}
+	get isOn() {
+		return this.drivers.ST.value !== 0;
+	}
+	get fanSpeed() {
+		return this.drivers.ST.value;
+	}
+
+	public async updateFanSpeed(level: number) {
+		return (level);
+	}
+	public async updateIsOn(isOn: boolean) {
+		if (!isOn) {
+			//return this.commands.BEEP(States.Level.Min);
+		} else {
+			//return this.commands.BEEP(States.Level.Max);
 		}
+	}
 
 }
 
 export class InsteonFanDevice extends InsteonBaseDevice {
-		constructor(isy: ISY, deviceNode: {
-				type: string;
-		}) {
-				super(isy, deviceNode);
-				this.Light = new InsteonDimmableDevice(isy, deviceNode);
-				this.addChild(this.Light);
+	public light?: InsteonDimmableDevice;
+	public motor: InsteonFanMotorDevice;
+	constructor(isy: ISY, deviceNode: NodeInfo) {
+		super(isy, deviceNode);
+		this.light = new InsteonDimmableDevice(isy, deviceNode);
+		this.light.events.on('PropertyChanged', ((a: any, b: any, c: any, d: string) => { this.emit('PropertyChanged', `light.${a}`, b, c, d); }).bind(this));
+		this.addChild(this.light);
+	}
 
+	public override handleEvent(event: { control?: string; data?: any; node?: any; }): boolean {
+		this.logger(JSON.stringify(event));
+		const child = this.children.find((p) => p.address === event.node);
+		if (child !== undefined) {
+			return child.handleEvent(event);
 		}
-		public Light: InsteonDimmableDevice;
-		public Motor: InsteonFanMotorDevice;
+		return false;
+	}
 
-		public handleEvent(event): boolean {
-				const child = this.children.find((p) => p.address === event.node);
-				if (child !== undefined) {
-						return child.handleEvent(event);
-				}
-				return null;
+	public override addChild(childDevice) {
+		super.addChild(childDevice);
+		if (childDevice instanceof InsteonFanMotorDevice) {
+			this.logger('Fan Motor Found');
+			this.motor = childDevice as InsteonFanMotorDevice;
+			this.motor.events.on('statusChanged', ((a: any, b: any, c: any, d: string) => { this.emit('PropertyChanged', `motor.${a}`, b, c, d); }).bind(this));
 		}
+	}
 
-		public addChild(childDevice: ISYDevice<Family.Insteon>) {
-				super.addChild(childDevice);
-				if (childDevice instanceof InsteonFanMotorDevice) {
-						this.logger('Fan Motor Found');
-						this.Motor = childDevice as InsteonFanMotorDevice;
-				}
-		}
+	public async updateFanSpeed(level: number) {
+		return this.motor.updateFanSpeed(level);
+	}
 
-		public async updateFanSpeed(level: number) {
-				return this.Motor.updateLevel(level);
-		}
-		public async updateIsOn(isOn: boolean) {
-				if (!isOn) {
-						this.Motor.updateLevel(States.Level.Min);
-				} else {
-						this.updateLevel(States.Fan.High);
-				}
-		}
 
 }

package/src/Devices/Insteon/InsteonKeypadDevice.ts

@@ -1,10 +1,11 @@
-import { ISY } from '../../ISY';
-import { KeypadDevice } from './InsteonDevice';
-import { InsteonRelayDevice } from './InsteonRelayDevice';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import { ISY } from '../../ISY.js';
+import { InsteonRelayDevice } from './InsteonRelayDevice.js';
+import 'winston';
 
 
 export class InsteonKeypadButtonDevice extends InsteonRelayDevice {
-	constructor (isy: ISY, deviceNode: any) {
+	constructor (isy: ISY, deviceNode: NodeInfo) {
 		super(isy, deviceNode);
 	}
 }

package/src/Devices/Insteon/InsteonKeypadDimmerDevice.ts

@@ -0,0 +1,11 @@
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import type { ISY } from '../../ISY.js';
+import { KeypadDevice } from './InsteonDevice.js';
+import { InsteonDimmableDevice } from './InsteonDimmableDevice.js';
+import 'winston';
+
+export class InsteonKeypadDimmerDevice extends InsteonDimmableDevice {
+	constructor (isy: ISY, deviceNode: NodeInfo) {
+		super(isy, deviceNode);
+	}
+}

package/src/Devices/Insteon/InsteonKeypadRelayDevice.ts

@@ -0,0 +1,10 @@
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import type { ISY } from '../../ISY.js';
+import { KeypadDevice } from './InsteonDevice.js';
+import { InsteonRelayDevice } from './InsteonRelayDevice.js';
+import 'winston';
+export class InsteonKeypadRelayDevice extends InsteonRelayDevice {
+	constructor (isy: ISY, deviceNode: NodeInfo) {
+		super(isy, deviceNode);
+	}
+}

package/src/Devices/Insteon/InsteonLeakSensorDevice.ts

@@ -1,14 +1,16 @@
-import { ISY } from '../../ISY';
-import { ISYBinaryStateDevice } from '../ISYDevice';
-import { InsteonBaseDevice } from './InsteonBaseDevice';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import { ISY } from '../../ISY.js';
+import { ISYBinaryStateDevice } from '../ISYDevice.js';
+import { InsteonBaseDevice } from './InsteonBaseDevice.js';
+import 'winston';
 
-export class InsteonLeakSensorDevice extends ISYBinaryStateDevice(InsteonBaseDevice) {
-	constructor (isy: ISY, deviceNode: {
-		type: string;
-	}) {
+export class InsteonLeakSensorDevice extends InsteonBaseDevice {
+	constructor (isy: ISY, deviceNode: NodeInfo) {
 		super(isy, deviceNode);
 	}
-	get leakDetected() {
-		return this.state;
+
+
+	get isDry() {
+		return this.drivers.ST;
 	}
 }

package/src/Devices/Insteon/InsteonLockDevice.ts

@@ -1,48 +1,26 @@
-import { ISY } from '../../ISY';
-import { Commands, DeviceTypes, States } from '../../ISYConstants';
-import { ISYBinaryStateDevice } from '../ISYDevice';
-import { InsteonBaseDevice } from './InsteonBaseDevice';
-
-export class InsteonLockDevice extends ISYBinaryStateDevice(InsteonBaseDevice) {
-	constructor (isy: ISY, deviceNode: {
-		type: string;
-	}) {
-		super(isy, deviceNode);
-	}
+import { ISY } from '../../ISY.js';
+import { Commands, States } from '../../ISYConstants.js';
+
+import { InsteonBaseDevice } from './InsteonBaseDevice.js';
+import 'winston';
+
+export class InsteonLockDevice extends InsteonBaseDevice {
+
 	public sendLockCommand(lockState: any, resultHandler: any) {
-		if (this.deviceType === DeviceTypes.lock) {
+
 			this.sendNonSecureLockCommand(lockState);
-		}
-		else if (this.deviceType === DeviceTypes.secureLock) {
+
 			this.sendSecureLockCommand(lockState);
-		}
-		else {
-			// assert(false, 'Should not ever have lock which is not one of the known lock types');
-		}
+
 	}
 	get isLocked() {
-		return this.state;
-	}
-	public getCurrentLockState() {
-		if (this.deviceType === DeviceTypes.lock) {
-			return this.getCurrentNonSecureLockState();
-		}
-		else if (this.deviceType === DeviceTypes.secureLock) {
-			return this.getCurrentSecureLockState();
-		}
-		else {
-			// assert(false, 'Should not ever have lock which is not one of the known lock types');
-		}
+		return this.drivers.ST.value > 0;
 	}
+
 	public async updateIsLocked(isLocked: boolean) {
-		return super.updateState(isLocked);
-	}
-	public getCurrentNonSecureLockState() {
-		return this.ST !== States.Lock.Locked;
-	}
-	public getCurrentSecureLockState() {
-		return this.ST > 0;
+		//return super.updateProperty(propertyName, value)
 	}
+
 	public async sendNonSecureLockCommand(lockState: any) {
 		if (lockState) {
 			return this.isy.sendNodeCommand(this, Commands.Lock.Lock);

package/src/Devices/Insteon/InsteonMotionSensorDevice.ts

@@ -1,42 +1,46 @@
-import { ISY } from '../../ISY';
-import { Commands } from '../../ISYConstants';
-import { InsteonBaseDevice } from './InsteonBaseDevice';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import { ISY } from '../../ISY.js';
+import { Commands } from '../../ISYConstants.js';
+import { InsteonBaseDevice } from './InsteonBaseDevice.js';
+import 'winston';
 
 export class InsteonMotionSensorDevice extends InsteonBaseDevice {
-	constructor (isy: ISY, deviceNode: {
-		type: string;
-	}) {
+	private _isMotionDetected: boolean;
+	constructor (isy: ISY, deviceNode: NodeInfo) {
 		super(isy, deviceNode);
 		this._isMotionDetected = false;
 	}
 
-	public handleEvent(event: {
-		control: string;
-	}) {
-		if (!super.handleEvent(event)) {
-			if (event.control === Commands.On) {
+	public override handleControlTrigger(controlName: string) {
+
+			if (controlName === Commands.On) {
 				this.logger('Motion detected.');
 				this._isMotionDetected = true;
-				this.propertyChanged.emit('', 'motionDetected', true, true);
+				this.emit('ControlTriggered',controlName);
+				this.emit('PropertyChanged', 'motionDetected', true, false, "true");
+
 				setTimeout(() => {
 					this.logger('No motion detected in last 30 seconds.');
 					this._isMotionDetected = false;
-					this.propertyChanged.emit('', 'motionDetected', false, false);
+					this.emit('PropertyChanged', 'motionDetected', false, true, "false"); /*Included for compatiblity purposes*/
 				}, 30000);
+				return true;
 			}
 
-			else if (event.control === Commands.Off) {
+			else if (controlName === Commands.Off) {
 				this._isMotionDetected = false;
 				this.logger('No motion detected.');
-				this.propertyChanged.emit('', 'motionDetected', false, false);
+				this.emit('ControlTriggered',controlName);
+				this.emit('PropertyChanged', 'motionDetected', false, true, "false");
+				return true;
 			}
-		}
-		return true;
+
+		return false;
 	}
-	get isMotionDetected() {
+	get motionDetected (): boolean{
 		return this._isMotionDetected;
 	}
 
 
-	
+
 }

package/src/Devices/Insteon/InsteonOnOffOutletDevice.ts

@@ -1,21 +1,24 @@
-import { ISY, ISYDevice, Family } from '../../ISY';
-import { InsteonRelayDevice } from './InsteonRelayDevice';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import { ISY } from '../../ISY.js';
+import { InsteonRelayDevice } from './InsteonRelayDevice.js';
+import 'winston';
 
 export class InsteonOnOffOutletDevice extends InsteonRelayDevice {
 
-	public outlet1 : InsteonRelayDevice;
-	public outlet2 : InsteonRelayDevice;
+	public outlet1: InsteonRelayDevice;
+	public outlet2: InsteonRelayDevice;
 
-	constructor(isy: ISY, deviceNode: any) {
+	constructor(isy: ISY, deviceNode: NodeInfo) {
 		super(isy, deviceNode);
 		this.outlet1 = new InsteonRelayDevice(isy, deviceNode);
+		//this.outlet1.on('PropertyChanged',(p,v,f) => this.handlePropertyChange("outlet1."+ p, v, f));
 		super.addChild(this.outlet1);
 
 	}
-	public addChild(childDevice: ISYDevice<Family.Insteon>) {
+	public override addChild(childDevice) {
 		super.addChild(childDevice);
 		this.outlet2 = childDevice as InsteonRelayDevice;
+		//this.outlet2.on('PropertyChanged', (p, v, f) => this.//handlePropertyChange("outlet2." + p, v, f));
 		// if(childDevice)
 	}
 }
-

package/src/Devices/Insteon/InsteonRelayDevice.ts

@@ -1,22 +1,64 @@
-import { ISY } from '../../ISY';
-import { ISYBinaryStateDevice } from '../ISYDevice';
-import { InsteonBaseDevice } from './InsteonBaseDevice';
-
-export class InsteonRelayDevice extends ISYBinaryStateDevice(InsteonBaseDevice) {
-	constructor (isy: ISY, node: {
-		type: string;
-	}) {
-		super(isy, node);
+import { Family, ISY } from '../../ISY.js';
+
+import { NodeInfo } from '../../Model/NodeInfo.js';
+import { EndpointFor } from '../EndpointFor.js';
+import { MapsTo } from '../MapsTo.js';
+import { InsteonBaseDevice } from './InsteonBaseDevice.js';
+
+import type { OnOffBehavior } from '@project-chip/matter.js/behaviors/on-off';
+import 'winston';
+import type { Command } from '../../Definitions/Global/Commands.js';
+import { Driver, DriverType } from '../../Definitions/Global/Drivers.js';
+import { UnitOfMeasure } from '../../Definitions/index.js';
+import { Properties } from '../../ISYConstants.js';
+
+import type { DriverState } from '../../Model/DriverState.js';
+
+export class InsteonRelayDevice extends InsteonBaseDevice<Driver.Signatures<'ST' | 'OL' | 'RR'>, Command.Signatures<'DON' | 'DOF'>> {
+	// #region Constructors (1)
+
+	constructor(isy: ISY, nodeInfo: NodeInfo) {
+		super(isy, nodeInfo);
+		this.drivers.ST = Driver.create('ST', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: 'Status', name: 'status' });
+		this.drivers.OL = Driver.create('OL', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: 'On Level', name: 'onLevel' });
+		this.drivers.RR = Driver.create('RR', this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: 'Ramp Rate', name: 'rampRate' });
 	}
-	get isOn() {
-		return this.state;
+
+	// #endregion Constructors (1)
+
+	// #region Public Methods (2)
+
+	public async initialize(endpoint: EndpointFor<typeof OnOffBehavior>): Promise<void> {
+		/*endpoint.events.onOff.onOff$Changed.on((value) => {
+			this.commands.DON(value);
+			this.drivers.ST;
+		});
+		//endpoint.defaults.onOff.onOff = await this.isOn;
+		endpoint.set({ onOff: { onOff: (await this.drivers.ST.value) > 0 } });
+		const that = this;
+
+		this.events.on('StatusChanged', (propertyName, newValue, _oldValue, formattedValue) => {
+			if (propertyName === 'ST') {
+				endpoint.set({ onOff: { onOff: newValue > 0 } });
+				//endpoint.setSt onOff: newValue });
+			}
+		});*/
 	}
+
+	/*
 	public async updateIsOn(isOn: boolean): Promise<any> {
-		if (this.isOn !== isOn) {
+		if (t !== isOn) {
+			this.isOn = true;
 			return super.updateState(isOn);
 		}
 		else {
 			return Promise.resolve();
 		}
+
+	} */
+	public override async sendBeep(level: number = 100): Promise<any> {
+		return super.sendBeep(level);
 	}
+
+	// #endregion Public Methods (2)
 }

package/src/Devices/Insteon/InsteonRelaySwitchDevice.ts

@@ -1,8 +1,11 @@
-import { InsteonSwitchDevice } from './InsteonDevice';
-import { InsteonRelayDevice } from './InsteonRelayDevice';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import type { ISY } from '../../ISY.js';
 
-export class InsteonRelaySwitchDevice extends InsteonSwitchDevice(InsteonRelayDevice) {
-	constructor (isy: any, deviceNode: any) {
+import { InsteonRelayDevice } from './InsteonRelayDevice.js';
+import 'winston';
+
+export class InsteonRelaySwitchDevice extends InsteonRelayDevice {
+	constructor (isy: ISY, deviceNode: NodeInfo ) {
 		super(isy, deviceNode);
 	}
 }

package/src/Devices/Insteon/InsteonSmokeSensorDevice.ts

@@ -1,14 +1,14 @@
-import { ISY } from '../../ISY';
-import { ISYBinaryStateDevice } from '../ISYDevice';
-import { InsteonBaseDevice } from './InsteonBaseDevice';
+import { ISY } from '../../ISY.js';
+import { ISYBinaryStateDevice } from '../ISYDevice.js';
+import { NodeInfo } from '../../Model/NodeInfo.js';
+import { InsteonBaseDevice } from './InsteonBaseDevice.js';
+import 'winston';
 
-export class InsteonSmokeSensorDevice extends ISYBinaryStateDevice(InsteonBaseDevice) {
-	constructor (isy: ISY, deviceNode: {
-		type: string;
-	}) {
+export class InsteonSmokeSensorDevice extends InsteonBaseDevice {
+	constructor(isy: ISY, deviceNode: NodeInfo ) {
 		super(isy, deviceNode);
 	}
 	get smokeDetected() {
-		return this.state;
+		return this.drivers.ST.value > 0;
 	}
 }