sportident.js 1.0.0

package/src/SiStation/BaseSiStation.test.ts

@@ -0,0 +1,221 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import type * as siProtocol from '../siProtocol';
+import * as testUtils from '../testUtils';
+import { proto } from '../constants';
+import { SiDataType } from '../storage';
+import { type ISiTargetMultiplexer, SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
+import { BaseSiStation } from './BaseSiStation';
+import { getSiStationExamples } from './siStationExamples';
+
+testUtils.useFakeTimers();
+
+describe('SiStation', () => {
+	class MySiStation extends BaseSiStation<SiTargetMultiplexerTarget.Direct> {}
+
+	test('SiStation info', async () => {
+		const mySiStation = new MySiStation({} as unknown as ISiTargetMultiplexer, SiTargetMultiplexerTarget.Direct);
+		interface MessageRecord {
+			target: SiTargetMultiplexerTarget;
+			command: number | undefined;
+			parameters: number[] | undefined;
+			numResponses: number | undefined;
+		}
+		const messagesSent: MessageRecord[] = [];
+		mySiStation.siTargetMultiplexer = {
+			sendMessage: (target, message, numResponses) => {
+				const command = message.mode === undefined ? message.command : undefined;
+				const parameters = message.mode === undefined ? message.parameters : undefined;
+				messagesSent.push({
+					target: target,
+					command: command,
+					parameters: parameters,
+					numResponses: numResponses
+				});
+				if (command === proto.cmd.GET_SYS_VAL) {
+					return Promise.resolve([[0x00, 0x00, 0x00, ..._.range(128)]]);
+				}
+				if (command === proto.cmd.SET_SYS_VAL) {
+					return Promise.resolve([[0x00, 0x00, 0x72]]);
+				}
+				throw new Error();
+			}
+		} as ISiTargetMultiplexer;
+		const timeState = { infoHasBeenRead: false, changesHaveBeenWritten: false };
+		mySiStation.readInfo().then(() => {
+			timeState.infoHasBeenRead = true;
+		});
+		expect(mySiStation.storage.data.toJS()).toEqual(_.range(128).map(() => undefined));
+		expect(mySiStation.getField('code') instanceof SiDataType).toBe(true);
+		expect(mySiStation.getInfo('code')).toBe(undefined);
+
+		await testUtils.advanceTimersByTime(0);
+		expect(messagesSent).toEqual([
+			{
+				target: SiTargetMultiplexerTarget.Direct,
+				command: proto.cmd.GET_SYS_VAL,
+				numResponses: 1,
+				parameters: [0, 128]
+			}
+		]);
+		expect(timeState).toEqual({ infoHasBeenRead: true, changesHaveBeenWritten: false });
+		expect(mySiStation.storage.data.toJS()).toEqual(_.range(128));
+		expect(mySiStation.getInfo('code')).not.toBe(undefined);
+		expect(mySiStation.setInfo('code', 0)).toBe(undefined);
+		expect(mySiStation.getInfo('code')!.value).toBe(0);
+		mySiStation.writeChanges().then(() => {
+			timeState.changesHaveBeenWritten = true;
+		});
+
+		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
+		expect(messagesSent).toEqual([
+			{
+				target: SiTargetMultiplexerTarget.Direct,
+				command: proto.cmd.GET_SYS_VAL,
+				numResponses: 1,
+				parameters: [0, 128]
+			},
+			{
+				target: SiTargetMultiplexerTarget.Direct,
+				command: proto.cmd.GET_SYS_VAL,
+				numResponses: 1,
+				parameters: [0, 128]
+			},
+			{
+				target: SiTargetMultiplexerTarget.Direct,
+				command: proto.cmd.SET_SYS_VAL,
+				numResponses: 1,
+				parameters: [0x72, 0x00, 0x33]
+			}
+		]);
+		expect(timeState).toEqual({ infoHasBeenRead: true, changesHaveBeenWritten: true });
+		mySiStation.atomically(() => {
+			mySiStation.setInfo('code', 10);
+		});
+
+		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
+		expect(messagesSent).toEqual([
+			{
+				target: SiTargetMultiplexerTarget.Direct,
+				command: proto.cmd.GET_SYS_VAL,
+				numResponses: 1,
+				parameters: [0, 128]
+			},
+			{
+				target: SiTargetMultiplexerTarget.Direct,
+				command: proto.cmd.GET_SYS_VAL,
+				numResponses: 1,
+				parameters: [0, 128]
+			},
+			{
+				target: SiTargetMultiplexerTarget.Direct,
+				command: proto.cmd.SET_SYS_VAL,
+				numResponses: 1,
+				parameters: [0x72, 0x00, 0x33]
+			},
+			{
+				target: SiTargetMultiplexerTarget.Direct,
+				command: proto.cmd.GET_SYS_VAL,
+				numResponses: 1,
+				parameters: [0, 128]
+			},
+			{
+				target: SiTargetMultiplexerTarget.Direct,
+				command: proto.cmd.SET_SYS_VAL,
+				numResponses: 1,
+				parameters: [0x72, 0x0a, 0x33]
+			}
+		]);
+		expect(mySiStation.getInfo('code')!.value).toBe(10);
+	});
+	const examples = getSiStationExamples();
+	Object.keys(examples).forEach((exampleName) => {
+		const { storageData, stationData } = examples[exampleName];
+		test(`works with ${exampleName} example`, (done) => {
+			const mySiStation = new MySiStation(
+				{
+					sendMessage: (_target: SiTargetMultiplexerTarget, message: siProtocol.SiMessage, numResponses: number) => {
+						if (message.mode !== undefined) {
+							return Promise.resolve([]);
+						}
+						const { command, parameters } = message;
+						if (command === proto.cmd.GET_SYS_VAL) {
+							const getRange = (offset: number, length: number) => [...[0x00, 0x00, offset], ...storageData.slice(offset, offset + length)];
+							if (numResponses !== 1) {
+								throw new Error(`Invalid numResponses ${numResponses} (expected 1)`);
+							}
+							return Promise.resolve([getRange(parameters![0]!, parameters![1]!)]);
+						}
+						return Promise.resolve([]);
+					}
+				} as unknown as ISiTargetMultiplexer,
+				SiTargetMultiplexerTarget.Direct
+			);
+			mySiStation.readInfo().then(() => {
+				Object.keys(stationData).forEach((stationDataKey) => {
+					// @ts-ignore
+					expect(mySiStation.getInfo(stationDataKey)!.value).toEqual(stationData[stationDataKey]);
+				});
+				done();
+			});
+		});
+	});
+
+	test('get/set time', async () => {
+		const mySiStation = new MySiStation(
+			{
+				sendMessage: () => Promise.resolve([[0x00, 0x00, 0x01, 0x0c, 0x1f, 0x00, 0xa8, 0xbf, 0x40]])
+			} as unknown as ISiTargetMultiplexer,
+			SiTargetMultiplexerTarget.Direct
+		);
+		const timeState: { [key: string]: Date | undefined } = {
+			retrievedTime: undefined,
+			setTime: undefined
+		};
+		mySiStation.getTime().then((time) => {
+			timeState.retrievedTime = time;
+		});
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
+		expect(timeState.retrievedTime instanceof Date).toBe(true);
+
+		mySiStation.setTime(new Date()).then((time) => {
+			timeState.setTime = time;
+		});
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
+		expect(timeState.setTime instanceof Date).toBe(true);
+	});
+	test('signal', async () => {
+		const mySiStation = new MySiStation(
+			{
+				sendMessage: () => Promise.resolve([[0x00, 0x00, 0x02]])
+			} as unknown as ISiTargetMultiplexer,
+			SiTargetMultiplexerTarget.Direct
+		);
+		const timeState = { signalTwiceSucceeded: false, signalOnceFailed: false };
+		mySiStation.signal(2).then(() => {
+			timeState.signalTwiceSucceeded = true;
+		});
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
+		expect(timeState).toEqual({ signalTwiceSucceeded: true, signalOnceFailed: false });
+
+		mySiStation.signal(1).catch(() => {
+			timeState.signalOnceFailed = true;
+		});
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
+		expect(timeState).toEqual({ signalTwiceSucceeded: true, signalOnceFailed: true });
+	});
+	test('powerOff', async () => {
+		const mySiStation = new MySiStation(
+			{
+				sendMessage: () => Promise.resolve()
+			} as unknown as ISiTargetMultiplexer,
+			SiTargetMultiplexerTarget.Direct
+		);
+		const timeState = { powerOffSucceeded: false };
+		mySiStation.powerOff().then(() => {
+			timeState.powerOffSucceeded = true;
+		});
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
+		expect(timeState).toEqual({ powerOffSucceeded: true });
+	});
+});

package/src/SiStation/BaseSiStation.ts

@@ -0,0 +1,253 @@
+import { proto } from '../constants';
+import * as storage from '../storage';
+import * as siProtocol from '../siProtocol';
+import { type ISiStation, SiStationMode, SiStationModel } from './ISiStation';
+import { type ISiTargetMultiplexer, SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
+
+export interface ISiStationStorageFields {
+	code: number;
+	mode: keyof typeof SiStationMode;
+	beeps: boolean;
+	flashes: boolean;
+	autoSend: boolean;
+	extendedProtocol: boolean;
+	serialNumber: number;
+	firmwareVersion: number;
+	buildDate: Date;
+	deviceModel: keyof typeof SiStationModel;
+	memorySize: number;
+	batteryDate: Date;
+	batteryCapacity: number;
+	batteryState: number;
+	backupPointer: number;
+	siCard6Mode: number;
+	memoryOverflow: number;
+	lastWriteDate: Date;
+	autoOffTimeout: number;
+	refreshRate: number;
+	powerMode: number;
+	interval: number;
+	wtf: number;
+	program: number;
+	handshake: boolean;
+	sprint4ms: boolean;
+	passwordOnly: boolean;
+	stopOnFullBackup: boolean;
+	autoReadout: boolean;
+	sleepDay: number;
+	sleepSeconds: number;
+	workingMinutes: number;
+}
+export const siStationStorageLocations: storage.ISiStorageLocations<ISiStationStorageFields> = {
+	code: new storage.SiInt([[0x72], [0x73, 6, 8]]),
+	mode: new storage.SiEnum([[0x71]], SiStationMode),
+	beeps: new storage.SiBool(0x73, 2),
+	flashes: new storage.SiBool(0x73, 0),
+	autoSend: new storage.SiBool(0x74, 1),
+	extendedProtocol: new storage.SiBool(0x74, 0),
+	serialNumber: new storage.SiInt([[0x03], [0x02], [0x01], [0x00]]),
+	firmwareVersion: new storage.SiInt([[0x07], [0x06], [0x05]]),
+	buildDate: new siProtocol.SiDate(3, (i) => 0x08 + i),
+	deviceModel: new storage.SiEnum([[0x0c], [0x0b]], SiStationModel),
+	memorySize: new storage.SiInt([[0x0d]]),
+	batteryDate: new siProtocol.SiDate(3, (i) => 0x15 + i),
+	batteryCapacity: new storage.SiInt([[0x1a], [0x19]]),
+	batteryState: new storage.SiInt([[0x37], [0x36], [0x35], [0x34]]),
+	// 2000mAh: 000000=0%, 6E0000=100%, 1000mAh:000000=0%, 370000=100%
+	backupPointer: new storage.SiInt([[0x22], [0x21], [0x1d], [0x1c]]),
+	siCard6Mode: new storage.SiInt([[0x33]]),
+	// 08 or FF = 192 punches, 00 or C1 normal
+	memoryOverflow: new storage.SiInt([[0x3d]]),
+	// overflow if != 00
+	lastWriteDate: new siProtocol.SiDate(6, (i) => 0x75 + i),
+	autoOffTimeout: new storage.SiInt([[0x7f], [0x7e]]),
+	refreshRate: new storage.SiInt([[0x10]]),
+	// in 3/sec ???
+	powerMode: new storage.SiInt([[0x11]]),
+	// 06 low power, 08 standard/sprint
+	interval: new storage.SiInt([[0x49], [0x48]]),
+	// in 32*ms
+	wtf: new storage.SiInt([[0x4b], [0x4a]]),
+	// in 32*ms
+	program: new storage.SiInt([[0x70]]),
+	// xx0xxxxxb competition, xx1xxxxxb training
+	handshake: new storage.SiBool(0x74, 2),
+	sprint4ms: new storage.SiBool(0x74, 3),
+	passwordOnly: new storage.SiBool(0x74, 4),
+	stopOnFullBackup: new storage.SiBool(0x74, 5),
+	autoReadout: new storage.SiBool(0x74, 7),
+	// depends on autoSend
+	sleepDay: new storage.SiInt([[0x7b]]),
+	//   xxxxxxx0b - seconds relative to midnight/midday: 0 = am, 1 = pm
+	//   xxxx000xb - day of week: 000 = Sunday, 110 = Saturday
+	//   xx00xxxxb - week counter 0..3, relative to programming date
+	sleepSeconds: new storage.SiInt([[0x7d], [0x7c]]),
+	workingMinutes: new storage.SiInt([[0x7f], [0x7e]])
+};
+export const siStationStorageDefinition = storage.defineStorage(0x80, siStationStorageLocations);
+// export type ISiStationStorageFields = storage.FieldsFromStorageDefinition<typeof siStationStorageDefinition>;
+// export type ISiStationStorageFields = storage.FieldsFromStorageLocations<typeof siStationStorageLocations>;
+
+export abstract class BaseSiStation<T extends SiTargetMultiplexerTarget> {
+	public storage: storage.ISiStorage<ISiStationStorageFields>;
+
+	protected static fromSiTargetMultiplexerWithGivenTarget<U extends SiTargetMultiplexerTarget>(
+		multiplexer: ISiTargetMultiplexer,
+		multiplexerTarget: U,
+		createNewInstance: () => ISiStation<U>
+	): ISiStation<U> {
+		const existingStationObject = multiplexer.stations[multiplexerTarget] as ISiStation<U> | undefined;
+		if (existingStationObject) {
+			return existingStationObject;
+		}
+		const instance = createNewInstance();
+		// @ts-ignore
+		multiplexer.stations[multiplexerTarget] = instance;
+		// TODO: deregister/close
+		return instance;
+	}
+
+	constructor(public siTargetMultiplexer: ISiTargetMultiplexer, public readonly multiplexerTarget: T) {
+		this.storage = siStationStorageDefinition();
+	}
+
+	get ident(): string {
+		const multiplexerTargetString = SiTargetMultiplexerTarget[this.multiplexerTarget];
+		const deviceIdentString = this.siTargetMultiplexer.siDevice.ident;
+		return `${multiplexerTargetString}-${deviceIdentString}`;
+	}
+
+	sendMessage(message: siProtocol.SiMessage, numResponses = 0, timeoutInMiliseconds = 10000): Promise<number[][]> {
+		return this.siTargetMultiplexer.sendMessage(this.multiplexerTarget, message, numResponses, timeoutInMiliseconds);
+	}
+
+	readInfo(): Promise<void> {
+		return this.sendMessage(
+			{
+				command: proto.cmd.GET_SYS_VAL,
+				parameters: [0x00, 0x80]
+			},
+			1
+		).then((data) => {
+			this.storage.splice(0x00, 0x80, ...data[0].slice(3));
+		});
+	}
+
+	getField<Field extends keyof ISiStationStorageFields>(infoName: Field): storage.ISiStorageLocations<ISiStationStorageFields>[Field] {
+		return this.storage.locations[infoName];
+	}
+
+	getInfo<Field extends keyof ISiStationStorageFields>(infoName: Field): storage.ISiFieldValue<ISiStationStorageFields[Field]> | undefined {
+		return this.storage.get(infoName);
+	}
+
+	setInfo<Field extends keyof ISiStationStorageFields>(infoName: Field, newValue: storage.ISiFieldValue<ISiStationStorageFields[Field]> | ISiStationStorageFields[Field]): void {
+		this.storage.set(infoName, newValue);
+	}
+
+	writeChanges(): Promise<void> {
+		const newStorage = this.storage.data;
+		return this.readInfo().then(() => {
+			const oldStorage = this.storage.data;
+			return this.writeDiff(oldStorage, newStorage);
+		});
+	}
+
+	atomically(doThings: () => void): Promise<void> {
+		return this.readInfo().then(() => {
+			const oldStorage = this.storage.data;
+			doThings();
+			const newStorage = this.storage.data;
+			return this.writeDiff(oldStorage, newStorage);
+		});
+	}
+
+	writeDiff(oldStorage: storage.ISiStorageData, newStorage: storage.ISiStorageData): Promise<void> {
+		const zippedStorageBytes = oldStorage.zip(newStorage);
+		const isByteDirty = zippedStorageBytes.map((oldAndNew: [unknown, unknown]) => oldAndNew[0] !== oldAndNew[1]);
+		const dirtyRanges = isByteDirty.reduce((ranges: [number, number][], isDirty: boolean, byteIndex: number): [number, number][] => {
+			if (!isDirty) {
+				return ranges;
+			}
+			const numRanges = ranges.length;
+			const lastRange = ranges[numRanges - 1];
+			if (lastRange && lastRange[1] === byteIndex) {
+				return [...ranges.slice(0, numRanges - 1), [lastRange[0], byteIndex + 1]];
+			}
+			return [...ranges, [byteIndex, byteIndex + 1]];
+		}, [] as [number, number][]);
+		let dirtyRangeIndex = 0;
+		const processDirtyRanges = (): Promise<void> => {
+			if (dirtyRangeIndex >= dirtyRanges.length) {
+				return Promise.resolve();
+			}
+			const dirtyRange = dirtyRanges[dirtyRangeIndex];
+			const parameters = [dirtyRange[0], ...newStorage.slice(dirtyRange[0], dirtyRange[1])] as number[];
+			return this.sendMessage(
+				{
+					command: proto.cmd.SET_SYS_VAL,
+					parameters: parameters
+				},
+				1
+			).then((d) => {
+				const data = d[0];
+				data.splice(0, 2);
+				if (data[0] !== parameters[0]) {
+					console.warn(`SET_SYS_VAL error: ${data[0]} (expected ${parameters[0]})`);
+				}
+				dirtyRangeIndex += 1;
+				return processDirtyRanges();
+			});
+		};
+		return processDirtyRanges();
+	}
+
+	
+
+	getTime(): Promise<Date | undefined> {
+		return this.sendMessage(
+			{
+				command: proto.cmd.GET_TIME,
+				parameters: []
+			},
+			1
+		).then((d) => siProtocol.arr2date(d[0].slice(2)));
+	}
+
+	setTime(newTime: Date): Promise<Date | undefined> {
+		// TODO: compensate for waiting time
+		return this.sendMessage(
+			{
+				command: proto.cmd.SET_TIME,
+				parameters: [...siProtocol.date2arr(newTime)]
+			},
+			1
+		).then((d) => siProtocol.arr2date(d[0].slice(2)));
+	}
+
+	signal(countArg: number): Promise<void> {
+		const count = countArg < 1 ? 1 : countArg;
+		return this.sendMessage(
+			{
+				command: proto.cmd.SIGNAL,
+				parameters: [count]
+			},
+			1
+		).then((data) => {
+			if (data[0][2] !== count) {
+				throw new Error('NUM BEEPS');
+			}
+		});
+	}
+
+	powerOff(): Promise<number[][]> {
+		// Does not power off BSM8 (USB powered), though
+		return this.sendMessage(
+			{
+				command: proto.cmd.OFF,
+				parameters: []
+			},
+			0
+		);
+	}
+}

package/src/SiStation/CoupledSiStation.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from '@jest/globals';
+import * as testUtils from '../testUtils';
+import type { ISiDevice, ISiDeviceDriverData } from '../SiDevice/ISiDevice';
+import type { ISiDeviceDriver } from '../SiDevice/ISiDeviceDriver';
+import { SiDevice } from '../SiDevice/SiDevice';
+import { SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
+import { CoupledSiStation } from './CoupledSiStation';
+import { SiTargetMultiplexer } from './SiTargetMultiplexer';
+
+testUtils.useFakeTimers();
+
+function mockDriver(driver: Partial<ISiDeviceDriver<ISiDeviceDriverData<unknown>>>) {
+	return driver as unknown as ISiDeviceDriver<ISiDeviceDriverData<unknown>>;
+}
+
+describe('CoupledSiStation', () => {
+	test('fromSiDevice', () => {
+		const fakeSiDevice = new SiDevice('fromSiDevice', {
+			driver: mockDriver({ name: 'FakeSiDevice' })
+		});
+		const myCoupledStation1 = CoupledSiStation.fromSiDevice(fakeSiDevice);
+		expect(myCoupledStation1 instanceof CoupledSiStation).toBe(true);
+		expect(myCoupledStation1.ident).toBe('Remote-FakeSiDevice-fromSiDevice');
+		expect(myCoupledStation1.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Remote);
+		const myCoupledStation2 = CoupledSiStation.fromSiDevice(fakeSiDevice);
+		expect(myCoupledStation2).toBe(myCoupledStation1);
+		expect(myCoupledStation2.ident).toBe('Remote-FakeSiDevice-fromSiDevice');
+		expect(myCoupledStation2.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Remote);
+	});
+	test('fromSiTargetMultiplexer', () => {
+		const myTargetMultiplexer = new SiTargetMultiplexer({ ident: 'fake-ident' } as ISiDevice<ISiDeviceDriverData<unknown>>);
+		const myCoupledStation1 = CoupledSiStation.fromSiTargetMultiplexer(myTargetMultiplexer);
+		expect(myCoupledStation1 instanceof CoupledSiStation).toBe(true);
+		expect(myCoupledStation1.ident).toBe('Remote-fake-ident');
+		expect(myCoupledStation1.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Remote);
+		const myCoupledStation2 = CoupledSiStation.fromSiTargetMultiplexer(myTargetMultiplexer);
+		expect(myCoupledStation2).toBe(myCoupledStation1);
+		expect(myCoupledStation2.ident).toBe('Remote-fake-ident');
+		expect(myCoupledStation2.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Remote);
+	});
+});

package/src/SiStation/CoupledSiStation.ts

@@ -0,0 +1,130 @@
+import type { ISiDevice, ISiDeviceDriverData } from '../SiDevice/ISiDevice';
+import type { ISiStation } from './ISiStation';
+import { type ISiTargetMultiplexer, SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
+import { BaseSiStation } from './BaseSiStation';
+import { SiTargetMultiplexer } from './SiTargetMultiplexer';
+import { proto } from '../constants';
+import * as siProtocol from '../siProtocol';
+
+export class CoupledSiStation extends BaseSiStation<SiTargetMultiplexerTarget.Remote> implements ISiStation<SiTargetMultiplexerTarget.Remote> {
+	static fromSiDevice(siDevice: ISiDevice<ISiDeviceDriverData<unknown>>): CoupledSiStation {
+		const multiplexer = SiTargetMultiplexer.fromSiDevice(siDevice);
+		return this.fromSiTargetMultiplexer(multiplexer);
+	}
+
+	static fromSiTargetMultiplexer(multiplexer: ISiTargetMultiplexer): CoupledSiStation {
+		return this.fromSiTargetMultiplexerWithGivenTarget(multiplexer, SiTargetMultiplexerTarget.Remote, () => new this(multiplexer, SiTargetMultiplexerTarget.Remote)) as CoupledSiStation;
+	}
+
+	async getBackupData(turnOff:boolean=true): Promise<{ code: number, cardNumber: number|undefined ; date: Date | undefined}[]> {
+		let backupData: { code: number, cardNumber: number|undefined ; date: Date | undefined}[] = []
+		let backupNextWritePointer:number = 0
+
+		// Get backup pointer
+		for(let tries = 0; tries<10 && (backupNextWritePointer == 0 || backupNextWritePointer == undefined); tries++){
+			try{
+				await this.siTargetMultiplexer.sendMessage(
+					SiTargetMultiplexerTarget.Remote,
+					{
+						command: proto.cmd.GET_SYS_VAL,
+						parameters: [0x1c,0x07]
+					}, 
+					1, 10000).then((d) => {
+						backupNextWritePointer = (d[0][3]<<24) | (d[0][4]<<16) | (d[0][8]<<8) | d[0][9]
+					}).catch(async (e) => {
+						await this.siTargetMultiplexer.sendMessage(
+							SiTargetMultiplexerTarget.Remote,
+							{
+								command: proto.WAKEUP,
+								parameters: []
+							}, 
+							0, 10000)
+						await new Promise( resolve => setTimeout(resolve, 500) );
+					})
+			}catch (e){ // ignore, try again
+			}
+		}
+		if(backupNextWritePointer == 0 || backupNextWritePointer == undefined){
+			return Promise.reject(new Error("Unable to access coupled si station!"))
+		}
+
+		
+		let backupReadLocation = 0x0100
+		let backupMaxLocation = 0x200000
+		let backupStorageSize = 128
+		while(backupReadLocation < backupNextWritePointer && backupReadLocation < backupMaxLocation){
+			try{
+				const actualReadLength = Math.min(backupStorageSize,backupNextWritePointer-backupReadLocation)
+				await this.siTargetMultiplexer.sendMessage(
+					SiTargetMultiplexerTarget.Remote,
+					{
+						command: proto.cmd.GET_BACKUP,
+						parameters: [(backupReadLocation>>16)&0xff,(backupReadLocation>>8)&0xff,backupReadLocation&0xff,actualReadLength]
+					}, 
+					1, 10000)
+					.then((d) => {
+						let cn = (d[0][0]<<8)|d[0][1]
+						let addr = (d[0][2]<<16)|(d[0][3]<<8)|d[0][4]
+						let p = 5
+						while (p<d[0].length){
+							let sicard = siProtocol.arr2cardNumber([d[0][p+2],d[0][p+1],d[0][p+0]])
+							let datedata = [
+								d[0][p+3]>>2, // Year = bit 7-2 
+								(((d[0][p+3]&0x3)<<2)|((d[0][p+4]>>6)&0x3)), // Month = bit 1-0 and 7-6
+								((d[0][p+4]>>1)&0x1F), // day = bit 5-1
+								(d[0][p+4]&0x1), // am/pm halfday = 0 bit
+								d[0][p+5],
+								d[0][p+6],
+								d[0][p+7]
+							]
+							let date = siProtocol.arr2date(datedata)
+							if(addr+p<=backupNextWritePointer){
+								backupData.push({code:cn,cardNumber:sicard,date:date})
+							}else{
+								break
+							}
+							p+=proto.REC_LEN
+						}
+						backupReadLocation += actualReadLength
+					})
+			}catch(e){
+				if(backupStorageSize >= 2*proto.REC_LEN){
+					backupStorageSize/=2
+					console.log("reduce requested backup block size to", backupStorageSize)
+				}else{
+					return Promise.reject("Unable to read backup data")
+				}
+			}
+
+		}
+
+		// Confirm read end with signal
+		await this.siTargetMultiplexer.sendMessage(
+			SiTargetMultiplexerTarget.Remote,
+			{
+				command: proto.cmd.SIGNAL,
+				parameters: [0x2]
+			}
+		)
+		// Turn of unit if requested
+		if(turnOff){
+			await new Promise( resolve => setTimeout(resolve, 250) );
+			for(let tries = 0, hasTurnedOff=false; tries<5&&!hasTurnedOff; tries++){
+				await this.siTargetMultiplexer.sendMessage(
+					SiTargetMultiplexerTarget.Remote,
+					{
+						command: proto.cmd.OFF,
+						parameters: []
+					}
+					,1,10000
+				).then(()=>{
+					hasTurnedOff = true
+				}).catch(e=>{
+					hasTurnedOff = false
+				})
+			}
+		}
+
+		return backupData
+	}
+}

package/src/SiStation/ISiMainStation.ts

@@ -0,0 +1,29 @@
+import type { ISiCard } from '../SiCard/ISiCard';
+import * as utils from '../utils';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ISiMainStation extends utils.IEventTarget<SiMainStationEvents> {}
+
+export class SiMainStationSiCardInsertedEvent extends utils.Event<'siCardInserted'> {
+	constructor(public siMainStation: ISiMainStation, public siCard: ISiCard) {
+		super();
+	}
+}
+
+export class SiMainStationSiCardRemovedEvent extends utils.Event<'siCardRemoved'> {
+	constructor(public siMainStation: ISiMainStation, public siCard: ISiCard) {
+		super();
+	}
+}
+
+export class SiMainStationSiCardObservedEvent extends utils.Event<'siCardObserved'> {
+	constructor(public siMainStation: ISiMainStation, public siCard: ISiCard) {
+		super();
+	}
+}
+
+export type SiMainStationEvents = {
+	siCardInserted: SiMainStationSiCardInsertedEvent;
+	siCardRemoved: SiMainStationSiCardRemovedEvent;
+	siCardObserved: SiMainStationSiCardObservedEvent;
+};

package/src/SiStation/ISiSendTask.ts

@@ -0,0 +1,9 @@
+/* eslint-disable no-unused-vars,no-shadow */
+export enum SiSendTaskState {
+	Queued = 0,
+	Sending = 1,
+	Sent = 2,
+	Succeeded = 3,
+	Failed = 4
+}
+/* eslint-enable no-unused-vars,no-shadow */