sportident.js 1.0.0

package/src/SiStation/SiTargetMultiplexer.ts

@@ -0,0 +1,241 @@
+import { proto } from '../constants';
+import * as utils from '../utils';
+import * as siProtocol from '../siProtocol';
+import type { ISiStation } from './ISiStation';
+import {
+	type _ISiTargetMultiplexerTestData,
+	type ISiTargetMultiplexer,
+	SiTargetMultiplexerDirectMessageEvent,
+	type SiTargetMultiplexerEvents,
+	SiTargetMultiplexerMessageEvent,
+	SiTargetMultiplexerRemoteMessageEvent,
+	SiTargetMultiplexerTarget
+} from './ISiTargetMultiplexer';
+import { type ISiDevice, type ISiDeviceDriverData, SiDeviceState } from '../SiDevice/ISiDevice';
+import { SiSendTaskState } from './ISiSendTask';
+import { SiSendTask } from './SiSendTask';
+
+/** Commands that can only be sent from a direct station. */
+export const DIRECT_DEVICE_INITIATED_COMMANDS: { [command: number]: boolean } = {
+	[proto.cmd.TRANS_REC]: true,
+	[proto.cmd.SI5_DET]: true,
+	[proto.cmd.SI6_DET]: true,
+	[proto.cmd.SI8_DET]: true,
+	[proto.cmd.SI_REM]: true
+};
+
+/** Commands that are sent from a station without prior request. */
+const DEVICE_INITIATED_COMMANDS: { [command: number]: boolean } = {
+	...DIRECT_DEVICE_INITIATED_COMMANDS,
+	[proto.cmd.SRR_PING]: true
+};
+
+export class SiTargetMultiplexer implements ISiTargetMultiplexer {
+	static fromSiDevice(siDevice: ISiDevice<ISiDeviceDriverData<unknown>>): ISiTargetMultiplexer {
+		if (siDevice.siTargetMultiplexer) {
+			return siDevice.siTargetMultiplexer;
+		}
+		const instance = new this(siDevice);
+		siDevice.siTargetMultiplexer = instance;
+		siDevice.addEventListener('stateChange', (e) => {
+			instance.handleDeviceStateChange(e.state);
+		});
+		siDevice.addEventListener('receive', (e) => {
+			instance.handleReceive(e.uint8Data);
+		});
+		// TODO: deregister/close
+		return instance;
+	}
+
+	public stations: { [Target in SiTargetMultiplexerTarget]?: ISiStation<Target> } = {};
+	public target: SiTargetMultiplexerTarget = SiTargetMultiplexerTarget.Unknown;
+	// the target of the latest command scheduled
+	public latestTarget: SiTargetMultiplexerTarget = SiTargetMultiplexerTarget.Unknown;
+	private receiveBuffer: number[] = [];
+	private sendQueue: SiSendTask[] = [];
+
+	// eslint-disable-next-line no-useless-constructor
+	constructor(
+		public siDevice: ISiDevice<ISiDeviceDriverData<unknown>> // eslint-disable-next-line no-empty-function
+	) {}
+
+	get _test(): _ISiTargetMultiplexerTestData {
+		return {
+			latestTarget: this.latestTarget,
+			sendQueue: this.sendQueue
+		};
+	}
+
+	handleDeviceStateChange(newState: SiDeviceState): void {
+		const actionByNewState: { [state in SiDeviceState]: () => void } = {
+			[SiDeviceState.Opening]: () => undefined,
+			[SiDeviceState.Opened]: () => this.startProcessingSendQueue(),
+			[SiDeviceState.Closing]: () => this.abortProcessingSendQueue(),
+			[SiDeviceState.Closed]: () => this.abortProcessingSendQueue()
+		};
+		const actionToPerform = actionByNewState[newState];
+		if (actionToPerform) {
+			actionToPerform();
+		}
+	}
+
+	startProcessingSendQueue(): void {
+		setTimeout(() => this._processSendQueue(), 1);
+	}
+
+	abortProcessingSendQueue(): void {
+		this.sendQueue.forEach((sendTask) => {
+			sendTask.fail();
+		});
+	}
+
+	handleReceive(uint8Data: number[]): void {
+		this.receiveBuffer.push(...uint8Data);
+		const { messages, remainder } = siProtocol.parseAll(this.receiveBuffer);
+		this.receiveBuffer = remainder;
+		messages.forEach((message) => {
+			this.updateSendQueueWithReceivedMessage(message);
+			this.dispatchEvent('message', new SiTargetMultiplexerMessageEvent(this, message));
+			if (this.target === SiTargetMultiplexerTarget.Direct) {
+				this.dispatchEvent('directMessage', new SiTargetMultiplexerDirectMessageEvent(this, message));
+			}
+			if (this.target === SiTargetMultiplexerTarget.Remote) {
+				this.dispatchEvent('remoteMessage', new SiTargetMultiplexerRemoteMessageEvent(this, message));
+			}
+		});
+	}
+
+	updateSendQueueWithReceivedMessage(message: siProtocol.SiMessage): void {
+		if (message.mode === undefined && DIRECT_DEVICE_INITIATED_COMMANDS[message.command]) {
+			console.debug('Received direct device-initiated command. Assuming target Direct...');
+			this.target = SiTargetMultiplexerTarget.Direct;
+			this.latestTarget = SiTargetMultiplexerTarget.Direct;
+		}
+		if (this.sendQueue.length === 0) {
+			return;
+		}
+		const shouldAcceptResponseInState: { [state in SiSendTaskState]: boolean } = {
+			[SiSendTaskState.Queued]: false,
+			[SiSendTaskState.Sending]: true, // This is mostly for testing purposes
+			[SiSendTaskState.Sent]: true,
+			[SiSendTaskState.Succeeded]: false,
+			[SiSendTaskState.Failed]: false
+		};
+		if (!shouldAcceptResponseInState[this.sendQueue[0].state]) {
+			return;
+		}
+		if (message.mode === proto.NAK) {
+			this.sendQueue[0].fail();
+			return;
+		}
+		if (message.mode !== undefined) {
+			return;
+		}
+		const expectedMessage = this.sendQueue[0].message;
+		if (expectedMessage.mode !== undefined) {
+			return;
+		}
+		if (message.command !== expectedMessage.command) {
+			if (DEVICE_INITIATED_COMMANDS[message.command] !== true) {
+				console.warn(`Strange Response: expected ${utils.prettyHex([expectedMessage.command])}, but got ${utils.prettyHex([message.command])}...`);
+			}
+			return;
+		}
+		this.sendQueue[0].addResponse(message.parameters);
+	}
+
+	async sendMessage(target: SiTargetMultiplexerTarget, message: siProtocol.SiMessage, numResponses?: number, timeoutInMiliseconds?: number): Promise<number[][]> {
+		console.warn("sendMessage to ",target)
+		return this.setTarget(target).then(() => this.sendMessageToLatestTarget(message, numResponses, timeoutInMiliseconds)).catch(e=>{console.warn(e); return Promise.reject(e)})
+	}
+
+	async setTarget(target: SiTargetMultiplexerTarget): Promise<void> {
+		console.warn("set Target to ",target, "last is ",this.latestTarget)
+		if (target === this.latestTarget) {
+			return Promise.resolve();
+		}
+		const setMsParameterByTarget: { [Target in SiTargetMultiplexerTarget]: number | undefined } = {
+			[SiTargetMultiplexerTarget.Direct]: proto.P_MS_DIRECT,
+			[SiTargetMultiplexerTarget.Remote]: proto.P_MS_REMOTE,
+			[SiTargetMultiplexerTarget.Unknown]: undefined,
+			[SiTargetMultiplexerTarget.Switching]: undefined
+		};
+		const setMsParameter = setMsParameterByTarget[target];
+		if (setMsParameter == undefined) {
+			console.warn("target is undefined, raise error")
+			return Promise.reject(new Error(`No such target: ${target}`));
+		}
+		this.latestTarget = target;
+		return this.sendMessageToLatestTarget(
+			{
+				command: proto.cmd.SET_MS,
+				parameters: [setMsParameter]
+			},
+			1
+		)
+			.then((responses: number[][]) => {
+				if (responses[0][2] !== setMsParameter) {
+					throw new Error('contradicting SET_MS response');
+				}
+				this.target = target;
+			})
+			.catch((err) => {
+				this.abortProcessingSendQueue();
+				this.target = SiTargetMultiplexerTarget.Unknown;
+				throw err;
+			});
+	}
+
+	sendMessageToLatestTarget(message: siProtocol.SiMessage, numResponses = 0, timeoutInMiliseconds = 10000): Promise<number[][]> {
+		return new Promise((resolve, reject) => {
+			const sendTask = new SiSendTask(
+				message,
+				numResponses,
+				timeoutInMiliseconds,
+				(resolvedTask) => {
+					const shifted = this.sendQueue.shift();
+					if (resolvedTask !== shifted) {
+						throw new Error('Resolved unexecuting SendTask');
+					}
+					setTimeout(() => this._processSendQueue(), 1);
+					resolve(resolvedTask.responses);
+				},
+				(rejectedTask) => {
+					const shifted = this.sendQueue.shift();
+					if (rejectedTask !== shifted) {
+						throw new Error('Rejected unexecuting SendTask');
+					}
+					setTimeout(() => this._processSendQueue(), 1);
+					reject(new Error('Rejection'));
+				}
+			);
+			this.sendQueue.push(sendTask);
+			this._processSendQueue();
+		});
+	}
+
+	_processSendQueue(): void {
+		if (this.sendQueue.length === 0 || this.sendQueue[0].state === SiSendTaskState.Sending || this.sendQueue[0].state === SiSendTaskState.Sent || this.siDevice.state !== SiDeviceState.Opened) {
+			return;
+		}
+
+		const sendTask = this.sendQueue[0];
+		sendTask.state = SiSendTaskState.Sending;
+		const uint8Data = [proto.WAKEUP, ...siProtocol.render(sendTask.message)];
+		this.siDevice
+			.send(uint8Data)
+			.then(() => {
+				sendTask.state = SiSendTaskState.Sent;
+				if (sendTask.numResponses <= 0) {
+					sendTask.succeed();
+				}
+			})
+			.catch((err: utils.SiError) => {
+				console.warn(`Error sending: ${err}`);
+				sendTask.fail();
+			});
+	}
+}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface SiTargetMultiplexer extends utils.EventTarget<SiTargetMultiplexerEvents> {}
+utils.applyMixins(SiTargetMultiplexer, [utils.EventTarget]);

package/src/SiStation/index.ts

@@ -0,0 +1,5 @@
+export { SiTargetMultiplexer } from './SiTargetMultiplexer';
+export { BaseSiStation } from './BaseSiStation';
+export { SiMainStation } from './SiMainStation';
+export { CoupledSiStation } from './CoupledSiStation';
+export { getSiStationExamples } from './siStationExamples';

package/src/SiStation/siStationExamples.ts

@@ -0,0 +1,103 @@
+import * as utils from '../utils';
+
+const cache = {};
+
+export interface StationSample {
+	stationData: { [attr: string]: unknown };
+	storageData: (number | undefined)[];
+}
+
+export const getBSM8Station = utils.cached(cache, () => ({
+	stationData: {
+		autoOffTimeout: 60,
+		autoReadout: false,
+		autoSend: false,
+		backupPointer: 256,
+		batteryCapacity: 14062,
+		batteryDate: new Date('2014-06-11 00:00:00'),
+		beeps: false,
+		buildDate: new Date('2014-06-11 00:00:00'),
+		code: 31,
+		deviceModel: 'BSM8',
+		extendedProtocol: true,
+		firmwareVersion: 3552567,
+		flashes: true,
+		handshake: true,
+		interval: 2621,
+		lastWriteDate: new Date('2019-06-20 23:17:13'),
+		memoryOverflow: 0,
+		memorySize: 128,
+		mode: 'Readout',
+		passwordOnly: false,
+		powerMode: 8,
+		program: 48,
+		refreshRate: 75,
+		serialNumber: 180641,
+		siCard6Mode: 193,
+		sprint4ms: false,
+		stopOnFullBackup: false,
+		wtf: 32760
+	},
+	storageData: [
+		...utils.unPrettyHex(`
+                00 02 C1 A1 F7 36 35 37 0E 06 0B 91 98 80 20 C0
+                4B 08 4E FA 28 0E 06 0B 00 36 EE 80 00 00 18 04
+                FF 01 00 00 00 00 00 00 00 00 00 00 4D 70 FF FF
+                FF 00 00 C1 00 00 00 0B 00 00 00 00 FF 00 FB E5
+                00 24 FC 18 FF FF 19 99 0A 3D 7F F8 85 0C 05 01
+                00 00 00 00 FF FF FF FF 00 00 01 0C FF FF FF FF
+                30 30 30 35 7D 20 38 00 00 00 00 00 FF FF FF FF
+                30 05 1F 33 05 13 06 14 01 9E B9 00 0E 12 00 3C
+            `)
+	]
+}));
+
+export const getBSM7Station = utils.cached(cache, () => ({
+	stationData: {
+		autoOffTimeout: 120,
+		autoReadout: false,
+		autoSend: false,
+		backupPointer: 1032,
+		batteryCapacity: 28125,
+		batteryDate: new Date('2016-08-04T00:00:00'),
+		beeps: true,
+		buildDate: new Date('2009-11-31 00:00:00'),
+		code: 10,
+		deviceModel: 'BSM7',
+		extendedProtocol: true,
+		firmwareVersion: 3551795,
+		flashes: true,
+		handshake: true,
+		interval: 1310,
+		lastWriteDate: new Date('2009-01-01T00:51:55'),
+		memoryOverflow: 0,
+		memorySize: 128,
+		mode: 'Readout',
+		passwordOnly: false,
+		powerMode: 8,
+		program: 36,
+		refreshRate: 75,
+		serialNumber: 130134,
+		siCard6Mode: 0,
+		sprint4ms: false,
+		stopOnFullBackup: false,
+		wtf: 32760
+	},
+	storageData: [
+		...utils.unPrettyHex(`
+                00 01 FC 56 F7 36 32 33 09 0C 01 91 97 80 20 DC
+                4B 08 4E FA 28 10 08 04 00 6D DD 00 00 00 18 04
+                00 04 08 00 00 00 00 00 00 00 00 00 4D 70 FF FF
+                01 0D 90 00 00 0C 17 28 00 00 00 00 00 00 F8 FF
+                00 24 02 E0 FF 38 19 99 05 1E 7F F8 85 0C 01 01
+                85 0C 6B 98 FF FF FF FF FF FF FF FF FF FF FF FF
+                30 30 30 35 7D 20 38 00 00 00 00 00 FF FF FF FF
+                24 05 0A 35 05 09 01 01 00 0C 2B 00 1C 22 00 78
+            `)
+	]
+}));
+
+export const getSiStationExamples = (): { [name: string]: StationSample } => ({
+	BSM8Station: getBSM8Station(),
+	BSM7Station: getBSM7Station()
+});

package/src/constants.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from '@jest/globals';
+import * as constants from './constants';
+
+describe('constants', () => {
+	describe('proto', () => {
+		test('basicCmd', () => {
+			expect('basicCmd' in constants.proto).toBe(true);
+			expect('basicCmdLookup' in constants.proto).toBe(true);
+			expect(constants.proto.basicCmdLookup).not.toBe(undefined);
+		});
+		test('cmd', () => {
+			expect('cmd' in constants.proto).toBe(true);
+			expect('cmdLookup' in constants.proto).toBe(true);
+			expect(constants.proto.cmdLookup).not.toBe(undefined);
+		});
+	});
+});

package/src/constants.ts

@@ -0,0 +1,92 @@
+import { getLookup } from './utils';
+
+export const proto = {
+	// Protocol characters
+	STX: 0x02,
+	ETX: 0x03,
+	ACK: 0x06, // when sent to BSx3..6, causes beep until SI-card taken out
+	NAK: 0x15,
+	DLE: 0x10,
+	WAKEUP: 0xff,
+
+	// Basic protocol commands, currently unused
+	basicCmd: {
+		SET_CARDNO: 0x30,
+		GET_SI5: 0x31, // read out SI-card 5 data
+		SI5_WRITE: 0x43, // 02 43 (block: 0x30 to 0x37) (16 bytes) 03
+		SI5_DET: 0x46, // SI-card 5 inserted (46 49) or removed (46 4F)
+		TRANS_REC: 0x53, // autosend timestamp (online control)
+		TRANS_TIME: 0x54, // autosend timestamp (lightbeam trigger)
+		GET_SI6: 0x61, // read out SI-card 6 data
+		SI6_DET: 0x66, // SI-card 6 inserted
+		SET_MS: 0x70, // \x4D="M"aster, \x53="S"lave
+		GET_MS: 0x71,
+		SET_SYS_VAL: 0x72,
+		GET_SYS_VAL: 0x73,
+		GET_BDATA: 0x74, // Note: response carries '\xC4'!
+		ERASE_BDATA: 0x75,
+		SET_TIME: 0x76,
+		GET_TIME: 0x77,
+		OFF: 0x78,
+		GET_BDATA2: 0x7a, // Note: response carries '\xCA'!
+		SET_BAUD: 0x7e // 0=4800 baud, 1=38400 baud
+	},
+	get basicCmdLookup(): { [value: number]: string } {
+		return getLookup(proto.basicCmd);
+	},
+
+	// Extended protocol commands
+	cmd: {
+		GET_BACKUP: 0x81,
+		SET_SYS_VAL: 0x82,
+		GET_SYS_VAL: 0x83,
+		SRR_WRITE: 0xa2, // ShortRangeRadio - SysData write
+		SRR_READ: 0xa3, // ShortRangeRadio - SysData read
+		SRR_QUERY: 0xa6, // ShortRangeRadio - network device query
+		SRR_PING: 0xa7, // ShortRangeRadio - heartbeat from linked devices, every 50 seconds
+		SRR_ADHOC: 0xa8, // ShortRangeRadio - ad-hoc message, f.ex. from SI-ActiveCard
+		GET_SI5: 0xb1, // read out SI-card 5 data
+		TRANS_REC: 0xd3, // autosend timestamp (online control)
+		CLEAR_CARD: 0xe0, // found on SI-dev-forum: 02 E0 00 E0 00 03 (http://www.sportident.com/en/forum/8/56#59)
+		GET_SI6: 0xe1, // read out SI-card 6 data block
+		SET_SI6: 0xe2, // write SI-card 6 line (16 bytes)
+		SET_SI6_SPECIAL: 0xe4, // write SI-card 6 special fields (e.g. start number)
+		SI5_DET: 0xe5, // SI-card 5 inserted
+		SI6_DET: 0xe6, // SI-card 6 inserted
+		SI_REM: 0xe7, // SI-card removed
+		SI8_DET: 0xe8, // SI-card 8/9/10/11/p/t inserted
+		SET_SI8: 0xea, // write SI-card 8/9/10/11/p/t data word
+		GET_SI8: 0xef, // read out SI-card 8/9/10/11/p/t data block
+		SET_MS: 0xf0, // \x4D="M"aster, \x53="S"lave
+		GET_MS: 0xf1,
+		ERASE_BDATA: 0xf5,
+		SET_TIME: 0xf6,
+		GET_TIME: 0xf7,
+		OFF: 0xf8,
+		SIGNAL: 0xf9, // 02 F9 (number of signals) (CRC16) 03
+		SET_BAUD: 0xfe // \x00=4800 baud, \x01=38400 baud
+	},
+	get cmdLookup(): { [value: number]: string } {
+		return getLookup(proto.cmd);
+	},
+
+	// If a punch has explicitly no time (e.g. if the start hasn't been punched)
+	NO_TIME: 0xeeee,
+
+	// Protocol Parameters
+	P_MS_DIRECT: 0x4d, // "M"aster
+	P_MS_REMOTE: 0x53, // "S"lave
+	P_SI6_CB: 0x08,
+
+	// Backup memory record length
+	REC_LEN: 8, // Only in extended protocol, otherwise 6!
+
+	// punch trigger in control mode data structure
+	T_OFFSET: 8,
+	T_CN: 0,
+	T_TIME: 5,
+
+	// backup memory in control mode
+	BC_CN: 3,
+	BC_TIME: 8
+};

package/src/fakes/FakeSiCard/BaseFakeSiCard.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, test } from '@jest/globals';
+import * as testUtils from '../../testUtils';
+import { BaseFakeSiCard } from './BaseFakeSiCard';
+
+testUtils.useFakeTimers();
+
+describe('BaseFakeSiCard', () => {
+	test('exists', () => {
+		expect(BaseFakeSiCard).not.toBe(undefined);
+	});
+});

package/src/fakes/FakeSiCard/BaseFakeSiCard.ts

@@ -0,0 +1,10 @@
+import type * as storage from '../../storage';
+import type * as siProtocol from '../../siProtocol';
+
+export abstract class BaseFakeSiCard {
+	public storage: storage.ISiStorage<unknown> = {} as storage.ISiStorage<unknown>;
+
+	abstract handleDetect(): siProtocol.SiMessage;
+
+	abstract handleRequest(message: siProtocol.SiMessage): siProtocol.SiMessage[];
+}

package/src/fakes/FakeSiCard/IFakeSiCard.ts

@@ -0,0 +1,6 @@
+import type * as siProtocol from '../../siProtocol';
+
+export interface IFakeSiCard {
+	handleDetect: () => siProtocol.SiMessage;
+	handleRequest: (message: siProtocol.SiMessage) => siProtocol.SiMessage[];
+}

package/src/fakes/FakeSiCard/index.ts

@@ -0,0 +1,2 @@
+export { BaseFakeSiCard } from './BaseFakeSiCard';
+export * from './types';

package/src/fakes/FakeSiCard/types/FakeModernSiCard.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from '@jest/globals';
+import { proto } from '../../../constants';
+import * as utils from '../../../utils';
+import * as testUtils from '../../../testUtils';
+import { FakeModernSiCard } from './FakeModernSiCard';
+import { getEmptyCard } from '../../../SiCard/types/modernSiCardExamples';
+
+testUtils.useFakeTimers();
+
+describe('FakeModernSiCard', () => {
+	test('exists', () => {
+		expect(FakeModernSiCard).not.toBe(undefined);
+	});
+	const testData = getEmptyCard();
+	const myFakeModernSiCard = new FakeModernSiCard(testData.storageData);
+	test('handleDetect works', () => {
+		expect(myFakeModernSiCard.handleDetect()).toEqual({
+			command: proto.cmd.SI8_DET,
+			parameters: utils.unPrettyHex('00 6B 96 8C')
+		});
+	});
+	test('handleRequest works', () => {
+		expect(() =>
+			myFakeModernSiCard.handleRequest({
+				command: proto.cmd.GET_SI5,
+				parameters: [0x06]
+			})
+		).toThrow();
+
+		expect(
+			myFakeModernSiCard.handleRequest({
+				command: proto.cmd.GET_SI8,
+				parameters: [0x06]
+			})
+		).toEqual([
+			{
+				command: proto.cmd.GET_SI8,
+				parameters: [6, ...testData.storageData.slice(6 * 128, 7 * 128)]
+			}
+		]);
+
+		expect(
+			myFakeModernSiCard.handleRequest({
+				command: proto.cmd.GET_SI8,
+				parameters: [0x08]
+			})
+		).toEqual([
+			{
+				command: proto.cmd.GET_SI8,
+				parameters: [0, ...testData.storageData.slice(0, 128)]
+			},
+			{
+				command: proto.cmd.GET_SI8,
+				parameters: [6, ...testData.storageData.slice(6 * 128, 7 * 128)]
+			},
+			{
+				command: proto.cmd.GET_SI8,
+				parameters: [7, ...testData.storageData.slice(7 * 128, 8 * 128)]
+			}
+		]);
+	});
+});

package/src/fakes/FakeSiCard/types/FakeModernSiCard.ts

@@ -0,0 +1,43 @@
+import _ from 'lodash';
+import { proto } from '../../../constants';
+import * as siProtocol from '../../../siProtocol';
+import { BaseFakeSiCard } from '../BaseFakeSiCard';
+import { type IModernSiCardStorageFields, ModernSiCard, modernSiCardStorageDefinition } from '../../../SiCard/types/ModernSiCard';
+import { getModernSiCardExamples } from '../../../SiCard/types/modernSiCardExamples';
+import type { ISiStorage } from '../../../storage';
+
+export class FakeModernSiCard extends BaseFakeSiCard {
+	static siCardClass = ModernSiCard;
+	static getAllExamples = getModernSiCardExamples;
+
+	storage: ISiStorage<IModernSiCardStorageFields>;
+
+	constructor(storage?: (number | undefined)[]) {
+		super();
+		this.storage = modernSiCardStorageDefinition(storage);
+	}
+
+	handleDetect(): siProtocol.SiMessage {
+		const cardNumberArr = siProtocol.cardNumber2arr(this.storage.get('cardNumber')!.value);
+		cardNumberArr.reverse();
+		return {
+			command: proto.cmd.SI8_DET,
+			parameters: [...cardNumberArr] as number[]
+		};
+	}
+
+	handleRequest(message: siProtocol.SiMessage): siProtocol.SiMessage[] {
+		if (message.mode !== undefined || message.command !== proto.cmd.GET_SI8 || message.parameters.length !== 1) {
+			throw new Error(`ModernSiCard can not handle ${siProtocol.prettyMessage(message)}`);
+		}
+		const pageIndex = message.parameters[0];
+		const getPageAtIndex = (index: number) => ({
+			command: proto.cmd.GET_SI8,
+			parameters: [index, ...this.storage.data.slice(index * 128, (index + 1) * 128).toJS()]
+		});
+		if (pageIndex === 0x08) {
+			return [0, 6, 7].map(getPageAtIndex) as siProtocol.SiMessage[];
+		}
+		return [getPageAtIndex(pageIndex)] as siProtocol.SiMessage[];
+	}
+}

package/src/fakes/FakeSiCard/types/FakeSIAC.ts

@@ -0,0 +1,17 @@
+import type * as storage from '../../../storage';
+import { type IModernSiCardStorageFields, modernSiCardStorageDefinition } from '../../../SiCard/types/ModernSiCard';
+import { FakeModernSiCard } from './FakeModernSiCard';
+import { SIAC } from '../../../SiCard/types/SIAC';
+import { getModernSiCardExamples } from '../../../SiCard/types/modernSiCardExamples';
+
+export class FakeSIAC extends FakeModernSiCard {
+	static siCardClass = SIAC;
+	static getAllExamples = getModernSiCardExamples;
+
+	public storage: storage.ISiStorage<IModernSiCardStorageFields>;
+
+	constructor(storageData: (number | undefined)[] | undefined) {
+		super();
+		this.storage = modernSiCardStorageDefinition(storageData);
+	}
+}

package/src/fakes/FakeSiCard/types/FakeSiCard10.ts

@@ -0,0 +1,17 @@
+import type * as storage from '../../../storage';
+import { type IModernSiCardStorageFields, modernSiCardStorageDefinition } from '../../../SiCard/types/ModernSiCard';
+import { FakeModernSiCard } from './FakeModernSiCard';
+import { SiCard10 } from '../../../SiCard/types/SiCard10';
+import { getModernSiCardExamples } from '../../../SiCard/types/modernSiCardExamples';
+
+export class FakeSiCard10 extends FakeModernSiCard {
+	static siCardClass = SiCard10;
+	static getAllExamples = getModernSiCardExamples;
+
+	public storage: storage.ISiStorage<IModernSiCardStorageFields>;
+
+	constructor(storageData: (number | undefined)[] | undefined) {
+		super();
+		this.storage = modernSiCardStorageDefinition(storageData);
+	}
+}

package/src/fakes/FakeSiCard/types/FakeSiCard11.ts

@@ -0,0 +1,17 @@
+import type * as storage from '../../../storage';
+import { type IModernSiCardStorageFields, modernSiCardStorageDefinition } from '../../../SiCard/types/ModernSiCard';
+import { FakeModernSiCard } from './FakeModernSiCard';
+import { SiCard11 } from '../../../SiCard/types/SiCard11';
+import { getModernSiCardExamples } from '../../../SiCard/types/modernSiCardExamples';
+
+export class FakeSiCard11 extends FakeModernSiCard {
+	static siCardClass = SiCard11;
+	static getAllExamples = getModernSiCardExamples;
+
+	public storage: storage.ISiStorage<IModernSiCardStorageFields>;
+
+	constructor(storageData: (number | undefined)[] | undefined) {
+		super();
+		this.storage = modernSiCardStorageDefinition(storageData);
+	}
+}