sportident.js 1.0.0

package/src/SiCard/types/SiCard5.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, test } from '@jest/globals';
+import { proto } from '../../constants';
+import type * as siProtocol from '../../siProtocol';
+import * as testUtils from '../../testUtils';
+import { BaseSiCard } from '../BaseSiCard';
+import { cropPunches, getPunchOffset, SiCard5 } from './SiCard5';
+import { getSiCard5Examples } from './siCard5Examples';
+import { FakeSiCard5 } from '../../fakes/FakeSiCard/types/FakeSiCard5';
+
+describe('SiCard5', () => {
+	test('is registered', () => {
+		expect(BaseSiCard.getTypeByCardNumber(999)).not.toEqual(SiCard5);
+		expect(BaseSiCard.getTypeByCardNumber(1000)).toEqual(SiCard5);
+		expect(BaseSiCard.getTypeByCardNumber(9999)).toEqual(SiCard5);
+		expect(BaseSiCard.getTypeByCardNumber(10000)).toEqual(SiCard5);
+		expect(BaseSiCard.getTypeByCardNumber(99999)).toEqual(SiCard5);
+		expect(BaseSiCard.getTypeByCardNumber(100000)).toEqual(SiCard5);
+		expect(BaseSiCard.getTypeByCardNumber(499999)).toEqual(SiCard5);
+		expect(BaseSiCard.getTypeByCardNumber(500000)).not.toEqual(SiCard5);
+	});
+	describe('typeSpecificInstanceFromMessage', () => {
+		test('works for valid message', () => {
+			const instance = SiCard5.typeSpecificInstanceFromMessage({
+				command: proto.cmd.SI5_DET,
+				parameters: [0x00, 0x00, 0x00, 0x01, 0x23, 0x45]
+			});
+			if (instance === undefined) {
+				throw new Error('expect instance');
+			}
+			expect(instance instanceof SiCard5).toBe(true);
+			expect(instance.cardNumber).toBe(109029);
+		});
+		test('returns undefined when message has mode', () => {
+			expect(
+				SiCard5.typeSpecificInstanceFromMessage({
+					mode: proto.NAK
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when message has wrong command', () => {
+			expect(
+				SiCard5.typeSpecificInstanceFromMessage({
+					command: testUtils.getRandomByteExcept([proto.cmd.SI5_DET]),
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when there are too few parameters', () => {
+			expect(
+				SiCard5.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI5_DET,
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+	});
+	test('getPunchOffset', () => {
+		expect(getPunchOffset(0)).toEqual(0x21);
+		expect(getPunchOffset(1)).toEqual(0x24);
+		expect(getPunchOffset(2)).toEqual(0x27);
+		expect(getPunchOffset(3)).toEqual(0x2a);
+		expect(getPunchOffset(4)).toEqual(0x2d);
+		expect(getPunchOffset(5)).toEqual(0x31);
+		expect(getPunchOffset(9)).toEqual(0x3d);
+		expect(getPunchOffset(10)).toEqual(0x41);
+		expect(getPunchOffset(14)).toEqual(0x4d);
+		expect(getPunchOffset(15)).toEqual(0x51);
+		expect(getPunchOffset(19)).toEqual(0x5d);
+		expect(getPunchOffset(20)).toEqual(0x61);
+		expect(getPunchOffset(24)).toEqual(0x6d);
+		expect(getPunchOffset(25)).toEqual(0x71);
+		expect(getPunchOffset(29)).toEqual(0x7d);
+		expect(getPunchOffset(30)).toEqual(0x20);
+		expect(getPunchOffset(31)).toEqual(0x30);
+		expect(getPunchOffset(32)).toEqual(0x40);
+		expect(getPunchOffset(33)).toEqual(0x50);
+		expect(getPunchOffset(34)).toEqual(0x60);
+		expect(getPunchOffset(35)).toEqual(0x70);
+	});
+	test('cropPunches', () => {
+		expect(cropPunches([])).toEqual([]);
+		expect(cropPunches([{ code: 31, time: {time:1} }])).toEqual([{ code: 31, time: {time:1} }]);
+		expect(cropPunches([{ code: 0, time: {time:1} }])).toEqual([]);
+		expect(cropPunches([{ code: undefined, time: undefined }])).toEqual([]);
+		expect(cropPunches([{ code: 33, time: undefined }])).toEqual([{ code: 33, time: undefined }]);
+		expect(
+			cropPunches([
+				{ code: 31, time: {time:1} },
+				{ code: 32, time: {time:2} },
+				{ code: 33, time: {time:3} },
+				{ code: 0, time: {time:4} },
+				{ code: undefined, time: undefined }
+			])
+		).toEqual([
+			{ code: 31, time: {time:1} },
+			{ code: 32, time: {time:2} },
+			{ code: 33, time: {time:3} }
+		]);
+	});
+	test('typeSpecificRead fails without mainStation', (done) => {
+		const mySiCard5 = new SiCard5(1);
+		mySiCard5.typeSpecificRead().then(
+			() => done(new Error('expect reject')),
+			() => done()
+		);
+	});
+	const examples = getSiCard5Examples();
+	Object.keys(examples).forEach((exampleName) => {
+		const { storageData, cardData } = examples[exampleName];
+		const myFakeSiCard5 = new FakeSiCard5(storageData);
+		const mainStationSimulation = {
+			sendMessage: (message: siProtocol.SiMessage, numResponses?: number) => {
+				const responses: siProtocol.SiMessage[] = myFakeSiCard5.handleRequest(message);
+				if (responses.length !== numResponses) {
+					throw new Error('Invalid numResponses');
+				}
+				return Promise.resolve(responses.map((response: siProtocol.SiMessage) => (response.mode === undefined ? [0x00, 0x00, ...response.parameters] : [])));
+			}
+		};
+
+		test(`typeSpecificRead works with ${exampleName} example`, (done) => {
+			const mySiCard5 = new SiCard5(cardData.cardNumber);
+			mySiCard5.mainStation = mainStationSimulation;
+			mySiCard5.typeSpecificRead().then(() => {
+				expect(mySiCard5.raceResult.cardNumber).toEqual(cardData.cardNumber);
+				expect(mySiCard5.raceResult.startTime).toEqual(cardData.startTime);
+				expect(mySiCard5.raceResult.finishTime).toEqual(cardData.finishTime);
+				expect(mySiCard5.raceResult.checkTime).toEqual(cardData.checkTime);
+				expect(mySiCard5.raceResult.punches).toEqual(cardData.punches);
+				expect(mySiCard5.punchCount).toEqual(cardData.punchCount);
+				done();
+			});
+		});
+
+		test(`typeSpecificRead works with wrong card number in ${exampleName} example`, (done) => {
+			const mySiCard5 = new SiCard5(cardData.cardNumber + 1);
+			mySiCard5.mainStation = mainStationSimulation;
+			mySiCard5.typeSpecificRead().then(() => {
+				expect(mySiCard5.raceResult.cardNumber).toEqual(cardData.cardNumber);
+				expect(mySiCard5.raceResult.startTime).toEqual(cardData.startTime);
+				expect(mySiCard5.raceResult.finishTime).toEqual(cardData.finishTime);
+				expect(mySiCard5.raceResult.checkTime).toEqual(cardData.checkTime);
+				expect(mySiCard5.raceResult.punches).toEqual(cardData.punches);
+				expect(mySiCard5.punchCount).toEqual(cardData.punchCount);
+				done();
+			});
+		});
+	});
+});

package/src/SiCard/types/SiCard5.ts

@@ -0,0 +1,129 @@
+import _ from 'lodash';
+import * as storage from '../../storage';
+import * as siProtocol from '../../siProtocol';
+import { proto } from '../../constants';
+import type { IBaseSiCardStorageFields } from '../ISiCard';
+import { BaseSiCard } from '../BaseSiCard';
+import type { IPunch } from '../IRaceResultData';
+
+const bytesPerPage = 128;
+const MAX_NUM_PUNCHES = 36;
+
+interface PotentialSiCard5Punch {
+	code: number | undefined;
+	time: siProtocol.SiTimestamp | undefined;
+}
+
+export const getPunchOffset = (i: number): number => (i >= 30 ? 0x20 + (i - 30) * 16 : 0x20 + Math.floor(i / 5) + 1 + i * 3);
+
+export const cropPunches = (allPunches: (PotentialSiCard5Punch | undefined)[]): IPunch[] => {
+	const isPunchEntryValid = (punch: PotentialSiCard5Punch | undefined): punch is IPunch => punch !== undefined && punch.code !== undefined && punch.code !== 0x00;
+	const firstInvalidIndex = allPunches.findIndex((punch) => !isPunchEntryValid(punch));
+	const punchesUntilInvalid = firstInvalidIndex === -1 ? allPunches : allPunches.slice(0, firstInvalidIndex);
+	return punchesUntilInvalid.filter<IPunch>(isPunchEntryValid);
+};
+
+export interface ISiCard5StorageFields extends IBaseSiCardStorageFields {
+	softwareVersion: number;
+	cardHolder: {
+		countryCode: number | undefined;
+		clubCode: number | undefined;
+	};
+}
+
+export const siCard5StorageLocations: storage.ISiStorageLocations<ISiCard5StorageFields> = {
+	cardNumber: new storage.SiModified(
+		new storage.SiArray(3, (i) => new storage.SiInt([[[0x05, 0x04, 0x06][i]]])),
+		(extractedValue) => siProtocol.arr2cardNumber(extractedValue)
+		// (cardNumber) => siProtocol.cardNumber2arr(cardNumber),
+		// (cardNumber) => `${cardNumber}`,
+		// (cardNumberString) => parseInt(cardNumberString, 10),
+		// (cardNumber) => cardNumber !== undefined && _.isInteger(cardNumber) && cardNumber >= 0,
+	),
+	startTime: new siProtocol.SiTime([[0x14], [0x13]]),
+	finishTime: new siProtocol.SiTime([[0x16], [0x15]]),
+	checkTime: new siProtocol.SiTime([[0x1a], [0x19]]),
+	punchCount: new storage.SiModified(new storage.SiInt([[0x17]]), (extractedValue) => extractedValue - 1),
+	punches: new storage.SiModified(
+		new storage.SiArray(
+			MAX_NUM_PUNCHES,
+			(i) =>
+				new storage.SiDict({
+					code: new storage.SiInt([[getPunchOffset(i) + 0]]),
+					time: new siProtocol.SiTime(i >= 30 ? undefined : [[getPunchOffset(i) + 2], [getPunchOffset(i) + 1]])
+				})
+		),
+		(allPunches) => cropPunches(allPunches)
+	),
+	cardHolder: new storage.SiDict({
+		countryCode: new storage.SiInt([[0x01]]),
+		clubCode: new storage.SiInt([[0x03], [0x02]])
+	}),
+	softwareVersion: new storage.SiInt([[0x1b]])
+};
+export const siCard5StorageDefinition = storage.defineStorage(0x80, siCard5StorageLocations);
+
+export class SiCard5 extends BaseSiCard {
+	static maxNumPunches = MAX_NUM_PUNCHES;
+
+	static typeSpecificInstanceFromMessage(message: siProtocol.SiMessage): SiCard5 | undefined {
+		if (message.mode !== undefined) {
+			return undefined;
+		}
+		if (message.command !== proto.cmd.SI5_DET) {
+			return undefined;
+		}
+		if (message.parameters.length < 6) {
+			return undefined;
+		}
+		const cardNumber = siProtocol.arr2cardNumber([message.parameters[5], message.parameters[4], message.parameters[3]]);
+		/* istanbul ignore next */
+		if (cardNumber === undefined) {
+			throw new Error('card number cannot be undefined');
+		}
+		return new this(cardNumber);
+	}
+
+	public storage: storage.ISiStorage<ISiCard5StorageFields>;
+
+	public punchCount?: number;
+	public softwareVersion?: number;
+
+	constructor(cardNumber: number) {
+		super(cardNumber);
+		this.storage = siCard5StorageDefinition();
+	}
+
+	typeSpecificRead(): Promise<void> {
+		if (!this.mainStation) {
+			return Promise.reject(new Error('No main station'));
+		}
+		return this.mainStation
+			.sendMessage(
+				{
+					command: proto.cmd.GET_SI5,
+					parameters: []
+				},
+				1
+			)
+			.then((data: number[][]) => {
+				this.storage.splice(bytesPerPage * 0, bytesPerPage, ...data[0].slice(2));
+
+				const readCardNumber = this.storage.get('cardNumber')!.value;
+				if (this.cardNumber !== readCardNumber) {
+					console.warn(`SICard5 Number ${readCardNumber} (expected ${this.cardNumber})`);
+				}
+				this.raceResult = {
+					cardNumber: this.storage.get('cardNumber')!.value,
+					startTime: this.storage.get('startTime')?.value,
+					finishTime: this.storage.get('finishTime')?.value,
+					checkTime: this.storage.get('checkTime')?.value,
+					punches: this.storage.get('punches')!.value,
+					cardHolder: this.storage.get('cardHolder')!.value
+				};
+				this.punchCount = this.storage.get('punchCount')!.value;
+				this.softwareVersion = this.storage.get('softwareVersion')!.value;
+			});
+	}
+}
+BaseSiCard.registerNumberRange(1000, 500000, SiCard5);

package/src/SiCard/types/SiCard6.test.ts

@@ -0,0 +1,179 @@
+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 { BaseSiCard } from '../BaseSiCard';
+import { cropPunches, getPunchOffset, SiCard6 } from './SiCard6';
+import { getSiCard6Examples } from './siCard6Examples';
+import { FakeSiCard6 } from '../../fakes/FakeSiCard/types/FakeSiCard6';
+
+describe('SiCard6', () => {
+	test('is registered', () => {
+		expect(BaseSiCard.getTypeByCardNumber(499999)).not.toEqual(SiCard6);
+		expect(BaseSiCard.getTypeByCardNumber(500000)).toEqual(SiCard6);
+		expect(BaseSiCard.getTypeByCardNumber(999999)).toEqual(SiCard6);
+		expect(BaseSiCard.getTypeByCardNumber(1000000)).not.toEqual(SiCard6);
+		expect(BaseSiCard.getTypeByCardNumber(2002999)).not.toEqual(SiCard6);
+		expect(BaseSiCard.getTypeByCardNumber(2003000)).toEqual(SiCard6);
+		expect(BaseSiCard.getTypeByCardNumber(2003999)).toEqual(SiCard6);
+		expect(BaseSiCard.getTypeByCardNumber(2004000)).not.toEqual(SiCard6);
+	});
+	describe('typeSpecificInstanceFromMessage', () => {
+		test('works for valid message', () => {
+			const instance = SiCard6.typeSpecificInstanceFromMessage({
+				command: proto.cmd.SI6_DET,
+				parameters: [0x00, 0x00, 0x00, 0x08, 0x88, 0x88]
+			});
+			if (instance === undefined) {
+				throw new Error('expect instance');
+			}
+			expect(instance instanceof SiCard6).toBe(true);
+			expect(instance.cardNumber).toBe(559240);
+		});
+		test('returns undefined when message has mode', () => {
+			expect(
+				SiCard6.typeSpecificInstanceFromMessage({
+					mode: proto.NAK
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when message has wrong command', () => {
+			expect(
+				SiCard6.typeSpecificInstanceFromMessage({
+					command: testUtils.getRandomByteExcept([proto.cmd.SI6_DET]),
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+		test('returns undefined when there are too few parameters', () => {
+			expect(
+				SiCard6.typeSpecificInstanceFromMessage({
+					command: proto.cmd.SI6_DET,
+					parameters: []
+				})
+			).toBe(undefined);
+		});
+	});
+	test('getPunchOffset', () => {
+		expect(getPunchOffset(0)).toEqual(0x300);
+		expect(getPunchOffset(1)).toEqual(0x304);
+		expect(getPunchOffset(63)).toEqual(0x3fc);
+	});
+	test('cropPunches', () => {
+		expect(cropPunches([])).toEqual([]);
+		expect(cropPunches([{ code: 31, time: {time:1} }])).toEqual([{ code: 31, time: {time:1} }]);
+		expect(cropPunches([{ code: 32, time: null }])).toEqual([]);
+		expect(cropPunches([{ code: undefined, time: undefined }])).toEqual([]);
+		expect(cropPunches([{ code: 33, time: undefined }])).toEqual([]);
+		expect(
+			cropPunches([
+				{ code: 31, time: {time:1} },
+				{ code: 32, time: {time:2} },
+				{ code: 33, time: {time:3} },
+				{ code: 0xee, time: null },
+				{ code: undefined, time: undefined }
+			])
+		).toEqual([
+			{ code: 31, time: {time:1} },
+			{ code: 32, time: {time:2} },
+			{ code: 33, time: {time:3} }
+		]);
+	});
+	test('typeSpecificRead fails without mainStation', (done) => {
+		const mySiCard6 = new SiCard6(1);
+		mySiCard6.typeSpecificRead().then(
+			() => done(new Error('expect reject')),
+			() => done()
+		);
+	});
+	const examples = getSiCard6Examples();
+	Object.keys(examples).forEach((exampleName) => {
+		const { storageData, cardData } = examples[exampleName];
+		const myFakeSiCard6 = new FakeSiCard6(storageData);
+		const mainStationSimulation = {
+			sendMessage: (message: siProtocol.SiMessage, numResponses?: number) => {
+				const responses: siProtocol.SiMessage[] = myFakeSiCard6.handleRequest(message);
+				if (responses.length !== numResponses) {
+					throw new Error('Invalid numResponses');
+				}
+				return Promise.resolve(responses.map((response: siProtocol.SiMessage) => (response.mode === undefined ? [0x00, 0x00, ...response.parameters] : [])));
+			}
+		};
+
+		test(`typeSpecificRead works with ${exampleName} example`, (done) => {
+			const mySiCard6 = new SiCard6(cardData.cardNumber);
+			mySiCard6.mainStation = mainStationSimulation;
+			mySiCard6.typeSpecificRead().then(() => {
+				expect(mySiCard6.raceResult.cardNumber).toEqual(cardData.cardNumber);
+				expect(mySiCard6.raceResult.startTime).toEqual(cardData.startTime);
+				expect(mySiCard6.raceResult.finishTime).toEqual(cardData.finishTime);
+				expect(mySiCard6.raceResult.clearTime).toEqual(cardData.clearTime);
+				expect(mySiCard6.raceResult.checkTime).toEqual(cardData.checkTime);
+				expect(mySiCard6.raceResult.punches).toEqual(cardData.punches);
+				expect(mySiCard6.raceResult.cardHolder).toEqual(cardData.cardHolder);
+				expect(mySiCard6.punchCount).toEqual(cardData.punchCount);
+				expect(mySiCard6.punchCountPlus1).toEqual(cardData.punchCountPlus1);
+				expect(mySiCard6.lastPunchedCode).toEqual(cardData.lastPunchedCode);
+				done();
+			});
+		});
+
+		test(`typeSpecificRead works with wrong card number in ${exampleName} example`, (done) => {
+			const mySiCard6 = new SiCard6(cardData.cardNumber + 1);
+			mySiCard6.mainStation = mainStationSimulation;
+			mySiCard6.typeSpecificRead().then(() => {
+				expect(mySiCard6.raceResult.cardNumber).toEqual(cardData.cardNumber);
+				expect(mySiCard6.raceResult.startTime).toEqual(cardData.startTime);
+				expect(mySiCard6.raceResult.finishTime).toEqual(cardData.finishTime);
+				expect(mySiCard6.raceResult.clearTime).toEqual(cardData.clearTime);
+				expect(mySiCard6.raceResult.checkTime).toEqual(cardData.checkTime);
+				expect(mySiCard6.raceResult.punches).toEqual(cardData.punches);
+				expect(mySiCard6.raceResult.cardHolder).toEqual(cardData.cardHolder);
+				expect(mySiCard6.punchCount).toEqual(cardData.punchCount);
+				expect(mySiCard6.punchCountPlus1).toEqual(cardData.punchCountPlus1);
+				expect(mySiCard6.lastPunchedCode).toEqual(cardData.lastPunchedCode);
+				done();
+			});
+		});
+	});
+	test('typeSpecificRead if typeSpecificReadCardHolder fails', (done) => {
+		const testError = new Error('test');
+		let typeSpecificReadCardHolderCalled = false;
+		class SiCard6WithoutCardHolder extends SiCard6 {
+			typeSpecificGetPage() {
+				return Promise.resolve(_.range(128).map(() => 0x00));
+			}
+
+			typeSpecificReadCardHolder() {
+				typeSpecificReadCardHolderCalled = true;
+				return Promise.reject(testError);
+			}
+		}
+		const mySiCard6 = new SiCard6WithoutCardHolder(654321);
+		mySiCard6.typeSpecificRead().catch((err) => {
+			expect(typeSpecificReadCardHolderCalled).toBe(true);
+			expect(err).toBe(testError);
+			done();
+		});
+	});
+	test('typeSpecificRead if typeSpecificReadPunches fails', (done) => {
+		const testError = new Error('test');
+		let attemptedToGetPage6 = false;
+		class SiCard6WithoutCardHolder extends SiCard6 {
+			typeSpecificGetPage(pageNumber: number) {
+				if (pageNumber === 6) {
+					attemptedToGetPage6 = true;
+					return Promise.reject(testError);
+				}
+				return Promise.resolve(_.range(128).map(() => 0x01));
+			}
+		}
+		const myModernSiCard = new SiCard6WithoutCardHolder(7123456);
+		myModernSiCard.typeSpecificRead().catch((err) => {
+			expect(attemptedToGetPage6).toBe(true);
+			expect(err).toBe(testError);
+			done();
+		});
+	});
+});

package/src/SiCard/types/SiCard6.ts

@@ -0,0 +1,222 @@
+import _ from 'lodash';
+import * as storage from '../../storage';
+import * as siProtocol from '../../siProtocol';
+import { proto } from '../../constants';
+import type { IBaseSiCardStorageFields } from '../ISiCard';
+import { BaseSiCard } from '../BaseSiCard';
+import type { IPunch } from '../IRaceResultData';
+
+class ReadFinishedException {}
+const punchesPerPage = 32;
+const bytesPerPage = 128;
+const MAX_NUM_PUNCHES = 64;
+
+interface PotentialSiCard6Punch {
+	code: number | undefined;
+	time: siProtocol.SiTimestamp | undefined;
+}
+
+export const getPunchOffset = (i: number): number => bytesPerPage * 6 + i * 4;
+
+export const cropPunches = (allPunches: (PotentialSiCard6Punch | undefined)[]): IPunch[] => {
+	const isPunchEntryValid = (punch: PotentialSiCard6Punch | undefined): punch is IPunch => punch !== undefined && punch.code !== undefined && punch.time !== undefined && punch.time !== null;
+	const firstInvalidIndex = allPunches.findIndex((punch) => !isPunchEntryValid(punch));
+	const punchesUntilInvalid = firstInvalidIndex === -1 ? allPunches : allPunches.slice(0, firstInvalidIndex);
+	return punchesUntilInvalid.filter<IPunch>(isPunchEntryValid);
+};
+
+const getCroppedString = (maybeCharCodes: (number | undefined)[]) => {
+	if (maybeCharCodes.some((maybeCharCode: number | undefined) => maybeCharCode === undefined)) {
+		return undefined;
+	}
+	const charCodes = maybeCharCodes as number[];
+	const isCharacterInvalid = (charCode: number) => charCode === 0x20;
+	const firstInvalidIndex = charCodes.findIndex(isCharacterInvalid);
+	const croppedCharCodes = firstInvalidIndex === -1 ? charCodes : charCodes.slice(0, firstInvalidIndex);
+	return croppedCharCodes.map((charCode: number) => String.fromCharCode(charCode)).join('');
+};
+
+export interface ISiCard6StorageFields extends IBaseSiCardStorageFields {
+	clearTime: siProtocol.SiTimestamp;
+	lastPunchedCode: number;
+	punchCountPlus1: number;
+	cardHolder: {
+		lastName: string | undefined;
+		firstName: string | undefined;
+		country: string | undefined;
+		club: string | undefined;
+		userId: string | undefined;
+		phone: string | undefined;
+		email: string | undefined;
+		street: string | undefined;
+		city: string | undefined;
+		zip: string | undefined;
+		gender: string | undefined;
+		birthday: string | undefined;
+		isComplete: boolean | undefined;
+	};
+}
+
+export const siCard6StorageLocations: storage.ISiStorageLocations<ISiCard6StorageFields> = {
+	cardNumber: new storage.SiModified(
+		new storage.SiArray(3, (i) => new storage.SiInt([[0x0b + (2 - i)]])),
+		(extractedValue) => siProtocol.arr2cardNumber(extractedValue)
+		// (cardNumber) => siProtocol.cardNumber2arr(cardNumber),
+		// (cardNumber) => `${cardNumber}`,
+		// (cardNumberString) => parseInt(cardNumberString, 10),
+		// (cardNumber) => cardNumber !== undefined && _.isInteger(cardNumber) && cardNumber >= 0,
+	),
+	startTime: new siProtocol.SiTime([[0x1b], [0x1a], [0x18]]),
+	finishTime: new siProtocol.SiTime([[0x17], [0x16], [0x14]]),
+	checkTime: new siProtocol.SiTime([[0x1f], [0x1e], [0x1c]]),
+	clearTime: new siProtocol.SiTime([[0x23], [0x22], [0x20]]),
+	lastPunchedCode: new storage.SiInt([[0x11], [0x10]]),
+	punchCount: new storage.SiInt([[0x12]]),
+	punchCountPlus1: new storage.SiInt([[0x13]]),
+	punches: new storage.SiModified(
+		new storage.SiArray(
+			MAX_NUM_PUNCHES,
+			(i) =>
+				new storage.SiDict({
+					code: new storage.SiInt([[getPunchOffset(i) + 1]]),
+					time: new siProtocol.SiTime([[getPunchOffset(i) + 3], [getPunchOffset(i) + 2], [getPunchOffset(i) + 0]])
+				})
+		),
+		(allPunches) => cropPunches(allPunches)
+	),
+	cardHolder: new storage.SiDict({
+		lastName: new storage.SiModified(new storage.SiArray(20, (i) => new storage.SiInt([[0x30 + i]])), (charCodes) => getCroppedString(charCodes)),
+		firstName: new storage.SiModified(new storage.SiArray(20, (i) => new storage.SiInt([[0x44 + i]])), (charCodes) => getCroppedString(charCodes)),
+		country: new storage.SiModified(new storage.SiArray(4, (i) => new storage.SiInt([[0x58 + i]])), (charCodes) => getCroppedString(charCodes)),
+		club: new storage.SiModified(new storage.SiArray(36, (i) => new storage.SiInt([[0x5c + i]])), (charCodes) => getCroppedString(charCodes)),
+		userId: new storage.SiModified(new storage.SiArray(16, (i) => new storage.SiInt([[0x80 + i]])), (charCodes) => getCroppedString(charCodes)),
+		phone: new storage.SiModified(new storage.SiArray(16, (i) => new storage.SiInt([[0x90 + i]])), (charCodes) => getCroppedString(charCodes)),
+		email: new storage.SiModified(new storage.SiArray(36, (i) => new storage.SiInt([[0xa0 + i]])), (charCodes) => getCroppedString(charCodes)),
+		street: new storage.SiModified(new storage.SiArray(20, (i) => new storage.SiInt([[0xc4 + i]])), (charCodes) => getCroppedString(charCodes)),
+		city: new storage.SiModified(new storage.SiArray(16, (i) => new storage.SiInt([[0xd8 + i]])), (charCodes) => getCroppedString(charCodes)),
+		zip: new storage.SiModified(new storage.SiArray(8, (i) => new storage.SiInt([[0xe8 + i]])), (charCodes) => getCroppedString(charCodes)),
+		gender: new storage.SiModified(new storage.SiArray(4, (i) => new storage.SiInt([[0xf0 + i]])), (charCodes) => getCroppedString(charCodes)),
+		birthday: new storage.SiModified(new storage.SiArray(8, (i) => new storage.SiInt([[0xf4 + i]])), (charCodes) => getCroppedString(charCodes)),
+		isComplete: new storage.SiModified(new storage.SiArray(0xd0, (i) => new storage.SiInt([[0x30 + i]])), (charCodes) => charCodes.every((charCode) => charCode !== undefined))
+	})
+};
+export const siCard6StorageDefinition = storage.defineStorage(0x400, siCard6StorageLocations);
+
+export class SiCard6 extends BaseSiCard {
+	static maxNumPunches = MAX_NUM_PUNCHES;
+
+	static typeSpecificInstanceFromMessage(message: siProtocol.SiMessage): SiCard6 | undefined {
+		if (message.mode !== undefined) {
+			return undefined;
+		}
+		if (message.command !== proto.cmd.SI6_DET) {
+			return undefined;
+		}
+		if (message.parameters.length < 6) {
+			return undefined;
+		}
+		const cardNumber = siProtocol.arr2cardNumber([message.parameters[5], message.parameters[4], message.parameters[3]]);
+		/* istanbul ignore next */
+		if (cardNumber === undefined) {
+			throw new Error('card number cannot be undefined');
+		}
+		return new this(cardNumber);
+	}
+
+	public storage: storage.ISiStorage<ISiCard6StorageFields>;
+
+	public punchCount?: number;
+	public punchCountPlus1?: number;
+	public lastPunchedCode?: number;
+
+	constructor(cardNumber: number) {
+		super(cardNumber);
+		this.storage = siCard6StorageDefinition();
+	}
+
+	typeSpecificGetPage(pageNumber: number): Promise<number[]> {
+		if (!this.mainStation) {
+			return Promise.reject(new Error('No main station'));
+		}
+		return this.mainStation
+			.sendMessage(
+				{
+					command: proto.cmd.GET_SI6,
+					parameters: [pageNumber]
+				},
+				1
+			)
+			.then((data: number[][]) => {
+				console.assert(data[0][2] === pageNumber, `Page number ${data[0][2]} retrieved (expected ${pageNumber})`);
+				return data[0].slice(3);
+			});
+	}
+
+	typeSpecificRead(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			this.typeSpecificReadBasic()
+				.then(() => this.typeSpecificReadCardHolder())
+				.then(() => this.typeSpecificReadPunches())
+				.then(() => {
+					this.raceResult = {
+						cardNumber: this.storage.get('cardNumber')!.value,
+						startTime: this.storage.get('startTime')?.value,
+						finishTime: this.storage.get('finishTime')?.value,
+						clearTime: this.storage.get('clearTime')?.value,
+						checkTime: this.storage.get('checkTime')?.value,
+						punches: this.storage.get('punches')!.value,
+						cardHolder: this.storage.get('cardHolder')!.value
+					};
+					this.punchCount = this.storage.get('punchCount')!.value;
+					this.punchCountPlus1 = this.storage.get('punchCountPlus1')!.value;
+					this.lastPunchedCode = this.storage.get('lastPunchedCode')!.value;
+					resolve();
+				})
+				.catch((exc: Error) => reject(exc));
+		});
+	}
+
+	typeSpecificReadBasic(): Promise<void> {
+		return this.typeSpecificGetPage(0).then((page0: number[]) => {
+			this.storage.splice(bytesPerPage * 0, bytesPerPage, ...page0);
+
+			const readCardNumber = this.storage.get('cardNumber')!.value;
+			if (this.cardNumber !== readCardNumber) {
+				console.warn(`SICard6 Number ${readCardNumber} (expected ${this.cardNumber})`);
+			}
+		});
+	}
+
+	typeSpecificReadCardHolder(): Promise<void> {
+		// TODO: test this with real device
+		return this.typeSpecificGetPage(1).then((page1: number[]) => {
+			this.storage.splice(bytesPerPage * 1, bytesPerPage, ...page1);
+		});
+	}
+
+	typeSpecificReadPunches(): Promise<void> {
+		if (this.storage.get('punchCount')!.value <= punchesPerPage * 0) {
+			return Promise.resolve();
+		}
+		return this.typeSpecificGetPage(6)
+			.then((page6: number[]) => {
+				this.storage.splice(bytesPerPage * 6, bytesPerPage, ...page6);
+				if (this.storage.get('punchCount')!.value <= punchesPerPage * 1) {
+					throw new ReadFinishedException();
+				}
+				return this.typeSpecificGetPage(7);
+			})
+			.then((page7: number[]) => {
+				this.storage.splice(bytesPerPage * 7, bytesPerPage, ...page7);
+				throw new ReadFinishedException();
+			})
+			.catch((exc: Error) => {
+				if (exc instanceof ReadFinishedException) {
+					return;
+				}
+				throw exc;
+			});
+	}
+}
+BaseSiCard.registerNumberRange(500000, 1000000, SiCard6);
+BaseSiCard.registerNumberRange(2003000, 2004000, SiCard6);