sportident.js 1.0.0

package/src/SiStation/ISiStation.ts

@@ -0,0 +1,88 @@
+import type { SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ISiStation<T extends SiTargetMultiplexerTarget> {
+	multiplexerTarget: T;
+	ident: string;
+}
+
+export const SiStationMode = {
+	SIACSpecialFunction1: 0x01, // Source: SI Config+
+	// 7B=battery test, 7C=on, 7D=off, 7F=radio readout
+	Control: 0x02, // Source: SI Config+
+	Start: 0x03, // Source: SI Config+
+	Finish: 0x04, // Source: SI Config+
+	Readout: 0x05, // Source: SI Config+
+	Clear: 0x07, // Source: SI Config+
+	Check: 0x0a, // Source: SI Config+
+	Print: 0x0b, // Source: old SI Config
+	StartWithTimeTrigger: 0x0c, // Source: old SI Config
+	FinishWithTimeTrigger: 0x0d, // Source: old SI Config
+	SIACSpecialFunction2: 0x11, // Source: SI Config+
+	// 7C=test
+	BCControl: 0x12, // Source: old SI Config
+	BCStart: 0x13, // Source: old SI Config
+	BCFinish: 0x14, // Source: old SI Config
+	BCSlave: 0x1f, // Source: old SI Config
+	BeaconControl: 0x32, // Source: SI Config+
+	BeaconStart: 0x33, // Source: SI Config+
+	BeaconFinish: 0x34 // Source: SI Config+
+};
+
+/* eslint-disable no-unused-vars,no-shadow */
+export enum SiStationType {
+	Main = 0x00,
+	Sprint = 0x01,
+	Print = 0x02,
+	Field = 0x03,
+	Master = 0x04
+}
+/* eslint-enable no-unused-vars,no-shadow */
+
+export const SiStationModel = {
+	BSF3: 0x8003,
+	BSF4: 0x8004,
+	BSF5: 0x8115,
+	BSF6: 0x8146,
+	BSF7A: 0x8117,
+	BSF7B: 0x8197,
+	BSF8A: 0x8118,
+	BSF8B: 0x8198,
+	BS7Master: 0x8187,
+	BS8Master: 0x8188,
+	BSM4: 0x8084,
+	BSM6: 0x8086,
+	BSM7: 0x9197,
+	BSM8: 0x9198,
+	BS7S: 0x9597,
+	BS7P: 0xb197,
+	BS7GSM: 0xb897,
+	BS8P: 0xb198
+};
+
+interface SiStationModelInfo {
+	description: string;
+	type: SiStationType;
+	series: number;
+}
+
+export const SI_STATION_MODEL_INFO: { [model in keyof typeof SiStationModel]: SiStationModelInfo } = {
+	BSF3: { description: 'BSF3', type: SiStationType.Field, series: 3 },
+	BSF4: { description: 'BSF4', type: SiStationType.Field, series: 4 },
+	BSF5: { description: 'BSF5', type: SiStationType.Field, series: 5 },
+	BSF6: { description: 'BSF6', type: SiStationType.Field, series: 6 },
+	BSF7A: { description: 'BSF7', type: SiStationType.Field, series: 7 },
+	BSF7B: { description: 'BSF7', type: SiStationType.Field, series: 7 },
+	BSF8A: { description: 'BSF8', type: SiStationType.Field, series: 8 },
+	BSF8B: { description: 'BSF8', type: SiStationType.Field, series: 8 },
+	BS7Master: { description: 'BS7-Master', type: SiStationType.Master, series: 7 },
+	BS8Master: { description: 'BS8-Master', type: SiStationType.Master, series: 8 },
+	BSM4: { description: 'BSM4', type: SiStationType.Main, series: 4 },
+	BSM6: { description: 'BSM6', type: SiStationType.Main, series: 6 },
+	BSM7: { description: 'BSM7', type: SiStationType.Main, series: 7 },
+	BSM8: { description: 'BSM8', type: SiStationType.Main, series: 8 },
+	BS7S: { description: 'BS7-S', type: SiStationType.Sprint, series: 7 },
+	BS7P: { description: 'BS7-P', type: SiStationType.Print, series: 7 },
+	BS7GSM: { description: 'BS7-GSM', type: SiStationType.Field, series: 7 },
+	BS8P: { description: 'BS8-P', type: SiStationType.Print, series: 8 }
+};

package/src/SiStation/ISiTargetMultiplexer.ts

@@ -0,0 +1,51 @@
+import * as utils from '../utils';
+import type * as siProtocol from '../siProtocol';
+import type { ISiDevice, ISiDeviceDriverData } from '../SiDevice/ISiDevice';
+import type { ISiStation } from './ISiStation';
+import type { SiSendTask } from './SiSendTask';
+
+export interface ISiTargetMultiplexer extends utils.IEventTarget<SiTargetMultiplexerEvents> {
+	_test: _ISiTargetMultiplexerTestData;
+	stations: { [Target in SiTargetMultiplexerTarget]?: ISiStation<Target> };
+	target: SiTargetMultiplexerTarget;
+	latestTarget: SiTargetMultiplexerTarget;
+	siDevice: ISiDevice<ISiDeviceDriverData<unknown>>;
+	sendMessage: (target: SiTargetMultiplexerTarget, message: siProtocol.SiMessage, numResponses?: number, timeoutInMiliseconds?: number) => Promise<number[][]>;
+	sendMessageToLatestTarget: (message: siProtocol.SiMessage, numResponses: number | undefined, timeoutInMiliseconds: number | undefined) => Promise<number[][]>;
+}
+
+export interface _ISiTargetMultiplexerTestData {
+	latestTarget: SiTargetMultiplexerTarget;
+	sendQueue: SiSendTask[];
+}
+
+/* eslint-disable no-unused-vars,no-shadow */
+export enum SiTargetMultiplexerTarget {
+	Unknown = 0,
+	Switching = 1,
+	Direct = 2,
+	Remote = 3
+}
+/* eslint-enable no-unused-vars,no-shadow */
+
+export class SiTargetMultiplexerMessageEvent extends utils.Event<'message'> {
+	constructor(public siTargetMultiplexer: ISiTargetMultiplexer, public message: siProtocol.SiMessage) {
+		super();
+	}
+}
+export class SiTargetMultiplexerDirectMessageEvent extends utils.Event<'directMessage'> {
+	constructor(public siTargetMultiplexer: ISiTargetMultiplexer, public message: siProtocol.SiMessage) {
+		super();
+	}
+}
+export class SiTargetMultiplexerRemoteMessageEvent extends utils.Event<'remoteMessage'> {
+	constructor(public siTargetMultiplexer: ISiTargetMultiplexer, public message: siProtocol.SiMessage) {
+		super();
+	}
+}
+
+export type SiTargetMultiplexerEvents = {
+	message: SiTargetMultiplexerMessageEvent;
+	directMessage: SiTargetMultiplexerDirectMessageEvent;
+	remoteMessage: SiTargetMultiplexerRemoteMessageEvent;
+};

package/src/SiStation/SiMainStation.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, test } from '@jest/globals';
+import _ from 'lodash';
+import { proto } from '../constants';
+import type * as siProtocol from '../siProtocol';
+import * as testUtils from '../testUtils';
+import type { ISiCard } from '../SiCard/ISiCard';
+import type { ISiDevice, ISiDeviceDriverData } from '../SiDevice/ISiDevice';
+import type { ISiDeviceDriver } from '../SiDevice/ISiDeviceDriver';
+import { SiDevice } from '../SiDevice/SiDevice';
+import { SiMainStationSiCardInsertedEvent, SiMainStationSiCardObservedEvent, SiMainStationSiCardRemovedEvent } from './ISiMainStation';
+import { type ISiTargetMultiplexer, SiTargetMultiplexerMessageEvent, SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
+import { SiTargetMultiplexer } from './SiTargetMultiplexer';
+import { siStationStorageDefinition } from './BaseSiStation';
+import { getBSM8Station } from './siStationExamples';
+import { SiMainStation } from './SiMainStation';
+import { getSiCard5Examples } from '../SiCard/types/siCard5Examples';
+import { getSiCard6Examples } from '../SiCard/types/siCard6Examples';
+import { FakeSiCard5 } from '../fakes/FakeSiCard/types/FakeSiCard5';
+import { FakeSiCard6 } from '../fakes/FakeSiCard/types/FakeSiCard6';
+
+testUtils.useFakeTimers();
+
+function mockDriver(driver: Partial<ISiDeviceDriver<ISiDeviceDriverData<unknown>>>) {
+	return driver as unknown as ISiDeviceDriver<ISiDeviceDriverData<unknown>>;
+}
+
+describe('SiMainStation', () => {
+	test('fromSiDevice', () => {
+		const fakeSiDevice = new SiDevice('fromSiDevice', {
+			driver: mockDriver({ name: 'FakeSiDevice' })
+		});
+		const myMainStation1 = SiMainStation.fromSiDevice(fakeSiDevice);
+		expect(myMainStation1 instanceof SiMainStation).toBe(true);
+		expect(myMainStation1.ident).toBe('Direct-FakeSiDevice-fromSiDevice');
+		expect(myMainStation1.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Direct);
+		const myMainStation2 = SiMainStation.fromSiDevice(fakeSiDevice);
+		expect(myMainStation2).toBe(myMainStation1);
+		expect(myMainStation2.ident).toBe('Direct-FakeSiDevice-fromSiDevice');
+		expect(myMainStation2.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Direct);
+	});
+	test('fromSiTargetMultiplexer', () => {
+		const myTargetMultiplexer = new SiTargetMultiplexer({ ident: 'fake-ident' } as ISiDevice<ISiDeviceDriverData<unknown>>);
+		const myMainStation1 = SiMainStation.fromSiTargetMultiplexer(myTargetMultiplexer);
+		expect(myMainStation1 instanceof SiMainStation).toBe(true);
+		expect(myMainStation1.ident).toBe('Direct-fake-ident');
+		expect(myMainStation1.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Direct);
+		const myMainStation2 = SiMainStation.fromSiTargetMultiplexer(myTargetMultiplexer);
+		expect(myMainStation2).toBe(myMainStation1);
+		expect(myMainStation2.ident).toBe('Direct-fake-ident');
+		expect(myMainStation2.multiplexerTarget).toBe(SiTargetMultiplexerTarget.Direct);
+	});
+
+	test('can readCards', async () => {
+		const storage = siStationStorageDefinition(getBSM8Station().storageData);
+		storage.set('mode', 'Control');
+		storage.set('code', 31);
+		storage.set('autoSend', true);
+		storage.set('handshake', false);
+		storage.set('beeps', false);
+		storage.set('flashes', false);
+		const fakeSiTargetMultiplexer = {
+			addEventListener: () => undefined,
+			sendMessage: (_target: SiTargetMultiplexerTarget, message: siProtocol.SiMessage, _numResponses: number) => {
+				if (message.mode !== undefined) {
+					throw new Error();
+				}
+				if (message.command === proto.cmd.GET_SYS_VAL) {
+					return Promise.resolve([[0x00, 0x00, 0x00, ...storage.data]]);
+				}
+				if (message.command === proto.cmd.SET_SYS_VAL) {
+					storage.splice(message.parameters[0], message.parameters.length - 1, ...message.parameters.slice(1));
+					return Promise.resolve([[0x00, 0x00, message.parameters[0]]]);
+				}
+				throw new Error();
+			}
+		} as unknown as ISiTargetMultiplexer;
+		const mySiStation = new SiMainStation(fakeSiTargetMultiplexer);
+		const cardsRead: ISiCard[] = [];
+		const cleanUpFunction = await mySiStation.readCards((card) => {
+			cardsRead.push(card);
+		});
+		await testUtils.nTimesAsync(3, () => testUtils.advanceTimersByTime(0));
+		if (cleanUpFunction === undefined) {
+			throw new Error('expect cleanUp function');
+		}
+		expect(storage.get('mode')!.value).toBe('Readout');
+		expect(storage.get('code')!.value).toBe(10);
+		expect(storage.get('autoSend')!.value).toBe(false);
+		expect(storage.get('handshake')!.value).toBe(true);
+		expect(storage.get('beeps')!.value).toBe(true);
+		expect(storage.get('flashes')!.value).toBe(true);
+
+		const fakeSiCard = {
+			cardNumber: 1234
+		} as ISiCard;
+		mySiStation.dispatchEvent('siCardInserted', new SiMainStationSiCardInsertedEvent(mySiStation, fakeSiCard));
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
+		expect(cardsRead).toEqual([{ cardNumber: 1234 } as ISiCard]);
+
+		const actualCleanUpFunction: () => Promise<void> = cleanUpFunction;
+		await actualCleanUpFunction();
+		expect(storage.get('mode')!.value).toBe('Control');
+		expect(storage.get('code')!.value).toBe(31);
+		expect(storage.get('autoSend')!.value).toBe(true);
+		expect(storage.get('handshake')!.value).toBe(false);
+		expect(storage.get('beeps')!.value).toBe(false);
+		expect(storage.get('flashes')!.value).toBe(false);
+
+		mySiStation.dispatchEvent('siCardInserted', new SiMainStationSiCardInsertedEvent(mySiStation, fakeSiCard));
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
+		// No additional entry
+		expect(cardsRead).toEqual([{ cardNumber: 1234 } as ISiCard]);
+	});
+
+	test('card detection & removal', async () => {
+		const myTargetMultiplexer = new SiTargetMultiplexer({} as ISiDevice<ISiDeviceDriverData<unknown>>);
+		const myMainStation = SiMainStation.fromSiTargetMultiplexer(myTargetMultiplexer);
+		const testData = getSiCard5Examples().fullCard;
+		const myFakeSiCard5 = new FakeSiCard5(testData.storageData);
+
+		const insertedCardNumbers: number[] = [];
+		const handleCardInserted = (e: SiMainStationSiCardInsertedEvent) => {
+			insertedCardNumbers.push(e.siCard.cardNumber);
+		};
+		myMainStation.addEventListener('siCardInserted', handleCardInserted);
+		const message = myFakeSiCard5.handleDetect() as siProtocol.SiMessageWithoutMode;
+		myTargetMultiplexer.dispatchEvent(
+			'message',
+			new SiTargetMultiplexerMessageEvent(myTargetMultiplexer, {
+				command: message.command,
+				parameters: [...[0x00, 0x00], ...message.parameters] as number[]
+			})
+		);
+		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
+		expect(insertedCardNumbers).toEqual([406402]);
+
+		const removedCardNumbers: number[] = [];
+		const handleCardRemoved = (e: SiMainStationSiCardRemovedEvent) => {
+			removedCardNumbers.push(e.siCard.cardNumber);
+		};
+		myMainStation.addEventListener('siCardRemoved', handleCardRemoved);
+		myTargetMultiplexer.dispatchEvent(
+			'message',
+			new SiTargetMultiplexerMessageEvent(myTargetMultiplexer, {
+				command: proto.cmd.SI_REM,
+				parameters: [...[0x00, 0x00], ...message.parameters] as number[]
+			})
+		);
+		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
+		expect(removedCardNumbers).toEqual([406402]);
+
+		myTargetMultiplexer.dispatchEvent(
+			'message',
+			new SiTargetMultiplexerMessageEvent(myTargetMultiplexer, {
+				command: proto.cmd.SI_REM,
+				parameters: [0x00, 0x00, 0x01, 0x23, 0x45, 0x67]
+			})
+		);
+		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
+		expect(removedCardNumbers).toEqual([406402]);
+
+		myMainStation.removeEventListener('siCardInserted', handleCardInserted);
+		myMainStation.removeEventListener('siCardRemoved', handleCardRemoved);
+	});
+	test('card observation', async () => {
+		const myTargetMultiplexer = new SiTargetMultiplexer({} as ISiDevice<ISiDeviceDriverData<unknown>>);
+		const myMainStation = SiMainStation.fromSiTargetMultiplexer(myTargetMultiplexer);
+		const testData = getSiCard6Examples().fullCard;
+		const myFakeSiCard6 = new FakeSiCard6(testData.storageData);
+		const observedCardNumbers: number[] = [];
+		const handleCardObserved = (e: SiMainStationSiCardObservedEvent) => {
+			observedCardNumbers.push(e.siCard.cardNumber);
+		};
+		myMainStation.addEventListener('siCardObserved', handleCardObserved);
+		const message = myFakeSiCard6.handleDetect() as siProtocol.SiMessageWithoutMode;
+		myTargetMultiplexer.dispatchEvent(
+			'message',
+			new SiTargetMultiplexerMessageEvent(myTargetMultiplexer, {
+				command: proto.cmd.TRANS_REC,
+				parameters: [...[0x00, 0x00], ...message.parameters] as number[]
+			})
+		);
+
+		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
+		expect(observedCardNumbers).toEqual([testData.cardData.cardNumber]);
+	});
+	test('card observation with mode', async () => {
+		const myTargetMultiplexer = new SiTargetMultiplexer({} as ISiDevice<ISiDeviceDriverData<unknown>>);
+		const myMainStation = SiMainStation.fromSiTargetMultiplexer(myTargetMultiplexer);
+		const observedCardNumbers: number[] = [];
+		const handleCardObserved = (e: SiMainStationSiCardObservedEvent) => {
+			observedCardNumbers.push(e.siCard.cardNumber);
+		};
+		myMainStation.addEventListener('siCardObserved', handleCardObserved);
+		myTargetMultiplexer.dispatchEvent('message', new SiTargetMultiplexerMessageEvent(myTargetMultiplexer, { mode: proto.NAK }));
+
+		await testUtils.nTimesAsync(2, () => testUtils.advanceTimersByTime(0));
+		expect(observedCardNumbers).toEqual([]);
+	});
+	test('other message', () => {
+		const fakeSiTargetMultiplexer = {
+			addEventListener: () => undefined,
+			sendMessage: () => Promise.resolve([])
+		} as unknown as ISiTargetMultiplexer;
+		const mySiStation = new SiMainStation(fakeSiTargetMultiplexer);
+		mySiStation.handleMessage({ command: proto.cmd.SIGNAL, parameters: [0x01] });
+	});
+
+	test('sendMessage', async () => {
+		const fakeSiTargetMultiplexer = {
+			addEventListener: () => undefined,
+			sendMessage: () => Promise.resolve([])
+		} as unknown as ISiTargetMultiplexer;
+		const mySiStation = new SiMainStation(fakeSiTargetMultiplexer);
+		let sendMessageSucceeded:boolean|undefined = undefined;
+		mySiStation.sendMessage({} as siProtocol.SiMessage).then(() => {
+			sendMessageSucceeded = true;
+		});
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
+		expect(sendMessageSucceeded).toBe(true);
+	});
+});

package/src/SiStation/SiMainStation.ts

@@ -0,0 +1,133 @@
+import * as utils from '../utils';
+import * as siProtocol from '../siProtocol';
+import { proto } from '../constants';
+import { BaseSiCard } from '../SiCard';
+import type { ISiCard } from '../SiCard/ISiCard';
+import type { ISiDevice, ISiDeviceDriverData } from '../SiDevice/ISiDevice';
+import type { ISiStation } from './ISiStation';
+import { type SiMainStationEvents, SiMainStationSiCardInsertedEvent, SiMainStationSiCardObservedEvent, SiMainStationSiCardRemovedEvent } from './ISiMainStation';
+import { type ISiTargetMultiplexer, SiTargetMultiplexerMessageEvent, SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
+import { BaseSiStation, type ISiStationStorageFields } from './BaseSiStation';
+import { SiTargetMultiplexer } from './SiTargetMultiplexer';
+
+type SiStationSetup = {
+	[key in keyof ISiStationStorageFields]?: ISiStationStorageFields[key];
+};
+
+type CleanUpFunction = () => Promise<void>;
+
+export class SiMainStation extends BaseSiStation<SiTargetMultiplexerTarget.Direct> implements ISiStation<SiTargetMultiplexerTarget.Direct> {
+	static fromSiDevice(siDevice: ISiDevice<ISiDeviceDriverData<unknown>>): SiMainStation {
+		const multiplexer = SiTargetMultiplexer.fromSiDevice(siDevice);
+		return this.fromSiTargetMultiplexer(multiplexer);
+	}
+
+	static fromSiTargetMultiplexer(multiplexer: ISiTargetMultiplexer): SiMainStation {
+		return this.fromSiTargetMultiplexerWithGivenTarget(multiplexer, SiTargetMultiplexerTarget.Direct, () => new this(multiplexer, SiTargetMultiplexerTarget.Direct)) as SiMainStation;
+	}
+
+	public siCard: ISiCard | null = null;
+
+	constructor(siTargetMultiplexer: ISiTargetMultiplexer, multiplexerTarget: SiTargetMultiplexerTarget.Direct = SiTargetMultiplexerTarget.Direct) {
+		super(siTargetMultiplexer, multiplexerTarget);
+		siTargetMultiplexer.addEventListener(
+			'message', // not directMessage, as the target might still be unknown, but we still need the message
+			(e: SiTargetMultiplexerMessageEvent) => {
+				const message = e.message;
+				this.handleMessage(message);
+				console.log(`There's a SiMainStation listening to this ${message}`);
+			}
+		);
+	}
+
+	readCards(onCardInserted: (card: ISiCard) => void, siStationSetupModification: SiStationSetup = {}): Promise<CleanUpFunction> {
+		const siStationSetup: SiStationSetup = {
+			code: 10,
+			mode: 'Readout',
+			autoSend: false,
+			handshake: true,
+			beeps: true,
+			flashes: true,
+			...siStationSetupModification
+		};
+		const siStationSetupKeys = Object.keys(siStationSetup) as (keyof ISiStationStorageFields)[];
+		const oldState: SiStationSetup = {};
+
+		const handleCardInserted = (e: SiMainStationSiCardInsertedEvent) => {
+			onCardInserted(e.siCard);
+		};
+
+		const cleanUp: CleanUpFunction = () => {
+			this.removeEventListener('siCardInserted', handleCardInserted);
+			return this.atomically(() => {
+				siStationSetupKeys.forEach((infoName) => {
+					const oldInfoValue = oldState[infoName];
+					if (oldInfoValue !== undefined) {
+						this.setInfo(infoName, oldInfoValue);
+					}
+				});
+			});
+		};
+
+		return this.atomically(() => {
+			siStationSetupKeys.forEach((infoName: keyof ISiStationStorageFields) => {
+				const oldFieldValue = this.getInfo(infoName);
+				// @ts-ignore
+				oldState[infoName] = oldFieldValue ? oldFieldValue.value : undefined;
+				const newValue = siStationSetup[infoName];
+				if (newValue !== undefined) {
+					this.setInfo(infoName, newValue);
+				}
+			});
+		}).then(() => {
+			this.addEventListener('siCardInserted', handleCardInserted);
+			return cleanUp;
+		});
+	}
+
+	handleMessage(message: siProtocol.SiMessage): void {
+		if (message.mode !== undefined) {
+			return;
+		}
+		const { command, parameters } = message;
+		const detectedSiCard = BaseSiCard.detectFromMessage(message);
+		if (detectedSiCard !== undefined) {
+			detectedSiCard.mainStation = this;
+			this.siCard = detectedSiCard as ISiCard;
+			this.dispatchEvent('siCardInserted', new SiMainStationSiCardInsertedEvent(this, detectedSiCard as ISiCard));
+			return;
+		}
+		const handleSiCardRemoved = () => {
+			const removedCardNumber = siProtocol.arr2cardNumber([parameters[5], parameters[4], parameters[3]]); // TODO: also [2]?
+			if (this.siCard !== null && this.siCard.cardNumber === removedCardNumber) {
+				this.dispatchEvent('siCardRemoved', new SiMainStationSiCardRemovedEvent(this, this.siCard));
+			} else {
+				console.warn(`Card ${removedCardNumber} was removed, but never inserted`);
+			}
+			this.siCard = null;
+		};
+		const handleSiCardObserved = () => {
+			const observedCardNumber = siProtocol.arr2cardNumber([parameters[5], parameters[4], parameters[3]]); // TODO: also [2]?
+			if (observedCardNumber === undefined) {
+				return;
+			}
+			const transRecordCard = BaseSiCard.fromCardNumber(observedCardNumber);
+			if (transRecordCard !== undefined) {
+				transRecordCard.mainStation = this;
+				this.dispatchEvent('siCardObserved', new SiMainStationSiCardObservedEvent(this, transRecordCard as ISiCard));
+			}
+		};
+		const handlerByCommand: { [command: number]: () => void } = {
+			[proto.cmd.SI_REM]: handleSiCardRemoved,
+			[proto.cmd.TRANS_REC]: handleSiCardObserved
+		};
+		const handler = handlerByCommand[command];
+		if (handler === undefined) {
+			return;
+		}
+		handler();
+	}
+}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface SiMainStation extends utils.EventTarget<SiMainStationEvents> {}
+utils.applyMixins(SiMainStation, [utils.EventTarget]);

package/src/SiStation/SiSendTask.ts

@@ -0,0 +1,50 @@
+import * as siProtocol from '../siProtocol';
+import { SiSendTaskState } from './ISiSendTask';
+
+export class SiSendTask {
+	public state: SiSendTaskState = SiSendTaskState.Queued;
+	public responses: number[][] = [];
+	private timeoutTimer: unknown;
+
+	constructor(
+		public message: siProtocol.SiMessage,
+		public numResponses: number,
+		public timeoutInMiliseconds: number,
+		public onResolve: (task: SiSendTask) => void,
+		public onReject: (task: SiSendTask) => void
+	) {
+		this.timeoutTimer = setTimeout(() => {
+			const shouldAbortInState: { [state in SiSendTaskState]: boolean } = {
+				[SiSendTaskState.Queued]: true,
+				[SiSendTaskState.Sending]: true,
+				[SiSendTaskState.Sent]: true,
+				[SiSendTaskState.Succeeded]: false,
+				[SiSendTaskState.Failed]: false
+			};
+			if (!shouldAbortInState[this.state]) {
+				return;
+			}
+			console.debug(`Timeout: ${siProtocol.prettyMessage(this.message)} (expected ${this.numResponses} responses)`, this.responses);
+			this.fail();
+		}, timeoutInMiliseconds);
+	}
+
+	addResponse(response: number[]): void {
+		this.responses.push(response);
+		if (this.responses.length === this.numResponses) {
+			this.succeed();
+		}
+	}
+
+	succeed(): void {
+		this.state = SiSendTaskState.Succeeded;
+		clearTimeout(this.timeoutTimer as Parameters<typeof clearTimeout>[0]);
+		this.onResolve(this);
+	}
+
+	fail(): void {
+		this.state = SiSendTaskState.Failed;
+		clearTimeout(this.timeoutTimer as Parameters<typeof clearTimeout>[0]);
+		this.onReject(this);
+	}
+}

package/src/SiStation/SiTargetMultiplexer.targeting.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, test } from '@jest/globals';
+import { proto } from '../constants';
+import * as siProtocol from '../siProtocol';
+import * as testUtils from '../testUtils';
+import { SiDevice } from '../SiDevice/SiDevice';
+import { SiDeviceState, SiDeviceReceiveEvent, type ISiDeviceDriverData } from '../SiDevice/ISiDevice';
+import type { ISiDeviceDriver } from '../SiDevice/ISiDeviceDriver';
+import { SiTargetMultiplexerTarget } from './ISiTargetMultiplexer';
+import { SiTargetMultiplexer } from './SiTargetMultiplexer';
+
+testUtils.useFakeTimers();
+
+function mockDriver(driver: Partial<ISiDeviceDriver<ISiDeviceDriverData<unknown>>>) {
+	return driver as unknown as ISiDeviceDriver<ISiDeviceDriverData<unknown>>;
+}
+
+describe('SiTargetMultiplexer', () => {
+	test('handles targeting', async () => {
+		const siDevice = new SiDevice('handlesTargeting0', {
+			driver: mockDriver({
+				send: () => Promise.resolve()
+			})
+		});
+		siDevice.setState(SiDeviceState.Opened);
+		const muxer = SiTargetMultiplexer.fromSiDevice(siDevice);
+		expect(muxer instanceof SiTargetMultiplexer).toBe(true);
+
+		const randomMessage = testUtils.getRandomMessage({});
+		const timeState = {
+			sendingFinished: false,
+			resendingFinished: false,
+			remoteSendingFinished: false
+		};
+		muxer.sendMessage(SiTargetMultiplexerTarget.Direct, randomMessage, 0, 1).then((responses) => {
+			expect(responses.length).toBe(0);
+			expect(muxer._test.sendQueue.length).toBe(0);
+			timeState.sendingFinished = true;
+		});
+		setTimeout(() => {
+			siDevice.dispatchEvent(
+				'receive',
+				new SiDeviceReceiveEvent(
+					siDevice,
+					siProtocol.render({
+						command: proto.cmd.SET_MS,
+						parameters: [0x00, 0x00, proto.P_MS_DIRECT]
+					})
+				)
+			);
+		}, 1);
+		expect(muxer.target).toBe(SiTargetMultiplexerTarget.Unknown);
+		expect(muxer._test.latestTarget).toBe(SiTargetMultiplexerTarget.Direct);
+		await testUtils.advanceTimersByTime(0); // resolve setTarget send promise
+		await testUtils.advanceTimersByTime(1); // trigger setTarget receive
+		await testUtils.nTimesAsync(10, () => testUtils.advanceTimersByTime(1));
+		expect(muxer.target).toBe(SiTargetMultiplexerTarget.Direct);
+		expect(muxer._test.latestTarget).toBe(SiTargetMultiplexerTarget.Direct);
+		await testUtils.advanceTimersByTime(0);
+		await testUtils.advanceTimersByTime(0);
+		expect(timeState).toEqual({
+			sendingFinished: true,
+			resendingFinished: false,
+			remoteSendingFinished: false
+		});
+
+		muxer.sendMessage(SiTargetMultiplexerTarget.Direct, randomMessage, 0, 1).then((responses) => {
+			expect(responses.length).toBe(0);
+			expect(muxer._test.sendQueue.length).toBe(0);
+			timeState.resendingFinished = true;
+		});
+		await testUtils.advanceTimersByTime(0);
+		await testUtils.advanceTimersByTime(0);
+		expect(muxer.target).toBe(SiTargetMultiplexerTarget.Direct);
+		expect(muxer._test.latestTarget).toBe(SiTargetMultiplexerTarget.Direct);
+		expect(timeState).toEqual({
+			sendingFinished: true,
+			resendingFinished: true,
+			remoteSendingFinished: false
+		});
+
+		muxer.sendMessage(SiTargetMultiplexerTarget.Remote, randomMessage, 0, 1).then((responses) => {
+			expect(responses.length).toBe(0);
+			expect(muxer._test.sendQueue.length).toBe(0);
+			timeState.remoteSendingFinished = true;
+		});
+		setTimeout(() => {
+			siDevice.dispatchEvent(
+				'receive',
+				new SiDeviceReceiveEvent(
+					siDevice,
+					siProtocol.render({
+						command: proto.cmd.SET_MS,
+						parameters: [0x00, 0x00, proto.P_MS_REMOTE]
+					})
+				)
+			);
+		}, 1);
+		expect(muxer.target).toBe(SiTargetMultiplexerTarget.Direct);
+		expect(muxer._test.latestTarget).toBe(SiTargetMultiplexerTarget.Remote);
+		await testUtils.advanceTimersByTime(0); // resolve setTarget send promise
+		await testUtils.advanceTimersByTime(1); // trigger setTarget receive
+		expect(muxer.target).toBe(SiTargetMultiplexerTarget.Remote);
+		expect(muxer._test.latestTarget).toBe(SiTargetMultiplexerTarget.Remote);
+		await testUtils.advanceTimersByTime(0);
+		await testUtils.advanceTimersByTime(0);
+		expect(timeState).toEqual({
+			sendingFinished: true,
+			resendingFinished: true,
+			remoteSendingFinished: true
+		});
+	});
+});