incyclist-devices 1.5.38 → 2.0.0

package/lib/serial/daum/premium/mock.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+import { MockBindingInterface, MockPortBinding, CreatePortOptions } from '@serialport/binding-mock';
+import { BindingInterface, PortInfo } from '@serialport/bindings-interface';
+import { User } from '../../../types/user';
+export type MockProps = {
+    interface: string;
+    path: string;
+};
+export interface Daum8iMockBindingInterface extends BindingInterface<Daum8iMockBinding> {
+    reset(): void;
+    createPort(path: string, opt?: CreatePortOptions): void;
+}
+export declare const Daum8iMock: MockBindingInterface;
+export declare class Daum8iMockImpl {
+    static _instance: Daum8iMockImpl;
+    static getInstance(): Daum8iMockImpl;
+    static reset(): void;
+    simulators: Map<string, Daum8MockSimulator>;
+    ports: {
+        path: string;
+        binding: Daum8iMockBinding;
+    }[];
+    constructor();
+    setSimulator(path: string, simulator: Daum8MockSimulator): void;
+    getSimulator(path: any): Daum8MockSimulator;
+    reset(): void;
+    createPort(path: string, options?: CreatePortOptions): void;
+    list(): Promise<PortInfo[]>;
+    open(options: any): Promise<Daum8iMockBinding>;
+}
+export declare class Daum8MockSimulator {
+    protoVersion: string;
+    dashboardVersion: string;
+    deviceType: number;
+    actualType: number;
+    gear: number;
+    power: number;
+    currentPower: number;
+    loadControl: number;
+    person: User;
+    _isSimulateACKTimeout: boolean;
+    _isSimulateCheckSumError: boolean;
+    _timeoutResponse: number;
+    timeoutNAKRetry: number;
+    simulateACKTimeout(): void;
+    simulateTimeout(ms: number): void;
+    simulateChecksumError(): void;
+    onNAK(): void;
+    onACK(): void;
+}
+export declare class Daum8iMockBinding extends MockPortBinding {
+    waitingForCommand: boolean;
+    waitingForAck: boolean;
+    prevCommand: Buffer;
+    simulator: Daum8MockSimulator;
+    handlers: Map<string, (payload: Buffer) => void>;
+    constructor(parent: MockPortBinding);
+    getPath(): string;
+    initHandlers(): void;
+    write(buffer: Buffer): Promise<void>;
+    processData(buffer: Buffer): Promise<void>;
+    createResponse(cmd: string, payload: Buffer): Buffer;
+    emitData(data: string | Buffer): void;
+    onGetProtcolVersion(_payload: Buffer): void;
+    onGetDashboardVersion(_payload: Buffer): void;
+    onGetDeviceType(_payload: Buffer): void;
+    onActualDeviceType(payload: Buffer): void;
+    onLoadControl(payload: Buffer): void;
+    onGear(payload: Buffer): void;
+    onPower(payload: Buffer): void;
+    onReservedCommand(payload: Buffer): void;
+    onPersonSet(payload: Buffer): void;
+    onPersonGet(): void;
+    onGetTrainingData(_payload: Buffer): void;
+}

package/lib/serial/daum/premium/mock.js

@@ -0,0 +1,289 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Daum8iMockBinding = exports.Daum8MockSimulator = exports.Daum8iMockImpl = exports.Daum8iMock = void 0;
+const binding_mock_1 = require("@serialport/binding-mock");
+const __1 = require("../../");
+const user_1 = require("../../../types/user");
+const utils_1 = require("../../../utils/utils");
+const utils_2 = require("./utils");
+exports.Daum8iMock = {
+    reset() {
+        Daum8iMockImpl.getInstance().reset();
+    },
+    createPort(path, options = {}) {
+        return Daum8iMockImpl.getInstance().createPort(path, options);
+    },
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Daum8iMockImpl.getInstance().list();
+        });
+    },
+    open(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Daum8iMockImpl.getInstance().open(options);
+        });
+    }
+};
+class Daum8iMockImpl {
+    static getInstance() {
+        if (!Daum8iMockImpl._instance)
+            Daum8iMockImpl._instance = new Daum8iMockImpl();
+        return Daum8iMockImpl._instance;
+    }
+    static reset() {
+        Daum8iMockImpl._instance = undefined;
+        __1.SerialPortProvider._instance = undefined;
+        __1.SerialInterface._instances = [];
+    }
+    constructor() {
+        this.simulators = new Map();
+        this.ports = [];
+    }
+    setSimulator(path, simulator) {
+        this.simulators.set(path, simulator);
+    }
+    getSimulator(path) {
+        return this.simulators.get(path);
+    }
+    reset() {
+        binding_mock_1.MockBinding.reset();
+    }
+    createPort(path, options = {}) {
+        return binding_mock_1.MockBinding.createPort(path, options);
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return binding_mock_1.MockBinding.list();
+        });
+    }
+    open(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const port = yield binding_mock_1.MockBinding.open(options);
+            return new Daum8iMockBinding(port);
+        });
+    }
+}
+exports.Daum8iMockImpl = Daum8iMockImpl;
+class Daum8MockSimulator {
+    constructor() {
+        this.protoVersion = '201';
+        this.dashboardVersion = 'Version 1.380';
+        this.deviceType = 0;
+        this.actualType = 0;
+        this.gear = 10;
+        this.power = 0;
+        this.currentPower = 0;
+        this.loadControl = 1;
+        this.person = { weight: 75, length: 180, age: 30, sex: user_1.Gender.MALE };
+        this._isSimulateACKTimeout = false;
+        this._isSimulateCheckSumError = false;
+        this._timeoutResponse = 0;
+        this.timeoutNAKRetry = 1000;
+    }
+    simulateACKTimeout() {
+        this._isSimulateACKTimeout = true;
+    }
+    simulateTimeout(ms) {
+        this._timeoutResponse = ms;
+    }
+    simulateChecksumError() {
+        this._isSimulateCheckSumError = true;
+    }
+    onNAK() { }
+    onACK() { }
+}
+exports.Daum8MockSimulator = Daum8MockSimulator;
+class Daum8iMockBinding extends binding_mock_1.MockPortBinding {
+    constructor(parent) {
+        super(parent.port, parent.openOptions);
+        this.waitingForAck = false;
+        this.waitingForCommand = true;
+        this.prevCommand = null;
+        this.simulator = Daum8iMockImpl.getInstance().getSimulator(this.getPath());
+        if (!this.simulator) {
+            this.simulator = new Daum8MockSimulator();
+            Daum8iMockImpl.getInstance().setSimulator(this.getPath(), this.simulator);
+        }
+        this.initHandlers();
+    }
+    getPath() {
+        return this.port.info.path;
+    }
+    initHandlers() {
+        this.handlers = new Map();
+        this.handlers.set('V00', this.onGetProtcolVersion.bind(this));
+        this.handlers.set('V70', this.onGetDashboardVersion.bind(this));
+        this.handlers.set('Y00', this.onGetDeviceType.bind(this));
+        this.handlers.set('M72', this.onActualDeviceType.bind(this));
+        this.handlers.set('M71', this.onGear.bind(this));
+        this.handlers.set('S20', this.onLoadControl.bind(this));
+        this.handlers.set('S23', this.onPower.bind(this));
+        this.handlers.set('M70', this.onReservedCommand.bind(this));
+        this.handlers.set('X70', this.onGetTrainingData.bind(this));
+    }
+    write(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!Buffer.isBuffer(buffer)) {
+                throw new TypeError('"buffer" is not a Buffer');
+            }
+            if (!this.isOpen || !this.port) {
+                throw new Error('Port is not open');
+            }
+            if (this.writeOperation) {
+                throw new Error('Overlapping writes are not supported and should be queued by the serialport object');
+            }
+            this.writeOperation = (() => __awaiter(this, void 0, void 0, function* () {
+                yield (0, utils_1.resolveNextTick)();
+                if (!this.isOpen || !this.port) {
+                    throw new Error('Write canceled');
+                }
+                if (this.simulator._isSimulateACKTimeout) {
+                    this.simulator._isSimulateACKTimeout = false;
+                }
+                else {
+                    setTimeout(() => { this.processData(buffer); }, 5);
+                }
+                this.writeOperation = null;
+            }))();
+            return this.writeOperation;
+        });
+    }
+    processData(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.waitingForCommand) {
+                try {
+                    const str = buffer.toString('hex');
+                    if (str.startsWith('01') && str.endsWith('17')) {
+                        const cmd = buffer.subarray(1, 4).toString();
+                        const payload = buffer.subarray(4, buffer.length - 3);
+                        const checksumVal = buffer.subarray(buffer.length - 3, buffer.length - 1).toString();
+                        const check = (0, utils_2.checkSum)(buffer.subarray(1, 4), payload);
+                        const handler = this.handlers.get(cmd);
+                        if (checksumVal === check && handler) {
+                            this.emitData(Buffer.from([0x06]));
+                            this.waitingForCommand = true;
+                            const to = this.simulator._timeoutResponse;
+                            if (to) {
+                                yield (0, utils_1.sleep)(to);
+                                this.simulator._timeoutResponse = 0;
+                            }
+                            handler(payload);
+                            this.waitingForCommand = false;
+                            this.waitingForAck = true;
+                        }
+                        else {
+                            this.emitData(Buffer.from([0x15]));
+                            this.waitingForAck = false;
+                            this.waitingForCommand = true;
+                        }
+                    }
+                    else {
+                        this.emitData(Buffer.from([0x15]));
+                        this.waitingForAck = false;
+                        this.waitingForCommand = true;
+                    }
+                }
+                catch (err) {
+                }
+            }
+            else if (this.waitingForAck) {
+                const c = buffer.readUInt8(0);
+                if (c === 0x06) {
+                    this.simulator.onACK();
+                    this.waitingForAck = false;
+                    this.waitingForCommand = true;
+                    this.prevCommand = null;
+                }
+                else if (c === 0x15) {
+                    this.simulator.onNAK();
+                    if (this.prevCommand) {
+                        const to = this.simulator.timeoutNAKRetry || 1000;
+                        setTimeout(() => {
+                            this.emitData(this.prevCommand);
+                            this.waitingForCommand = false;
+                            this.waitingForAck = true;
+                        }, to);
+                    }
+                }
+            }
+        });
+    }
+    createResponse(cmd, payload) {
+        const buffer = Buffer.from((0, utils_2.buildMessage)(cmd, payload));
+        this.prevCommand = Buffer.from(buffer);
+        if (this.simulator._isSimulateCheckSumError) {
+            this.simulator._isSimulateCheckSumError = false;
+            buffer[buffer.length - 2] = buffer[buffer.length - 2] - 1;
+        }
+        return buffer;
+    }
+    emitData(data) {
+        if (!this.isOpen || !this.port)
+            return;
+        super.emitData(data);
+    }
+    onGetProtcolVersion(_payload) {
+        this.emitData(this.createResponse('V00', Buffer.from(this.simulator.protoVersion)));
+    }
+    onGetDashboardVersion(_payload) {
+        this.emitData(this.createResponse('V70', Buffer.from(this.simulator.dashboardVersion)));
+    }
+    onGetDeviceType(_payload) {
+        this.emitData(this.createResponse('Y00', Buffer.from(this.simulator.deviceType.toString())));
+    }
+    onActualDeviceType(payload) {
+        if (payload.length > 0) {
+            this.simulator.actualType = Number(payload.toString());
+        }
+        this.emitData(this.createResponse('M72', Buffer.from(this.simulator.actualType.toString())));
+    }
+    onLoadControl(payload) {
+        if (payload.length > 0) {
+            const loadControl = Number(payload.toString());
+            this.simulator.loadControl = loadControl;
+        }
+        this.emitData(this.createResponse('S20', Buffer.from(this.simulator.loadControl.toString())));
+    }
+    onGear(payload) {
+        if (payload.length > 0) {
+            const gear = Number(payload.toString());
+            this.simulator.gear = gear;
+        }
+        this.emitData(this.createResponse('M71', Buffer.from(this.simulator.gear.toString())));
+    }
+    onPower(payload) {
+        if (payload.length > 0) {
+            const power = Number(payload.toString());
+            this.simulator.power = power;
+            setTimeout(() => { this.simulator.currentPower = power; }, 1000);
+        }
+        this.emitData(this.createResponse('S23', Buffer.from(this.simulator.power.toString())));
+    }
+    onReservedCommand(payload) {
+        const cmd = payload.readInt16LE(0);
+        const length = payload.readUint16LE(2);
+        const data = (0, utils_2.esc2bin)(payload.subarray(4, 4 + length - 1));
+        switch (cmd) {
+            case utils_2.ReservedCommands.PERSON_SET: this.onPersonSet(Buffer.from(data));
+            case utils_2.ReservedCommands.PERSON_GET: this.onPersonGet();
+        }
+    }
+    onPersonSet(payload) {
+        this.simulator.person = (0, utils_2.parsePersonData)(payload);
+        this.emitData(this.createResponse('M70', Buffer.from('07000000', 'hex')));
+    }
+    onPersonGet() {
+    }
+    onGetTrainingData(_payload) {
+    }
+}
+exports.Daum8iMockBinding = Daum8iMockBinding;

package/lib/{daum/premium/DaumClassicCyclingMode.d.ts → serial/daum/premium/modes/daum-classic.d.ts}

@@ -1,6 +1,6 @@
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "../../cycling-mode";
-import DaumAdapter from "../DaumAdapter";
-import DaumPowerMeterCyclingMode from "../DaumPowerMeterCyclingMode";
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "../../../../modes/cycling-mode";
+import DaumAdapter from "../../DaumAdapter";
+import DaumPowerMeterCyclingMode from "../../DaumPowerMeterCyclingMode";
 export default class DaumClassicCyclingMode extends DaumPowerMeterCyclingMode implements CyclingMode {
     constructor(adapter: DaumAdapter, props?: Settings);
     getName(): string;

package/lib/{daum/premium/DaumClassicCyclingMode.js → serial/daum/premium/modes/daum-classic.js}

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const cycling_mode_1 = require("../../cycling-mode");
-const DaumPowerMeterCyclingMode_1 = __importDefault(require("../DaumPowerMeterCyclingMode"));
+const cycling_mode_1 = require("../../../../modes/cycling-mode");
+const DaumPowerMeterCyclingMode_1 = __importDefault(require("../../DaumPowerMeterCyclingMode"));
 const config = {
     name: "Daum Classic",
     description: "The device calculates speed and power based on slope. Incyclist will not modify any values recived from the device\nThis mode will not respect maximum power and/or workout limits",

package/lib/serial/daum/premium/types.d.ts

@@ -0,0 +1,12 @@
+import { DeviceProperties } from "../../../types/device";
+import { Route } from "../../../types/route";
+export type OnDeviceStartCallback = (completed: number, total: number) => void;
+export type DaumPremiumAdapterProps = {
+    path: string;
+    ifaceName: string;
+};
+export interface Daum8iDeviceProperties extends DeviceProperties {
+    route?: Route;
+    gear?: number;
+    onStatusUpdate?: OnDeviceStartCallback;
+}

package/lib/serial/daum/premium/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/{daum → serial/daum}/premium/utils.d.ts

@@ -1,22 +1,14 @@
 /// <reference types="node" />
-import { Route } from "../../types/route";
-import { User } from "../../types/user";
+import { Route } from "../../../types/route";
+import { User } from "../../../types/user";
 export declare function bin2esc(arr: any): any[];
 export declare function esc2bin(arr: any): any[];
 export declare function checkSum(cmdArr: any, payload: any): string;
 export declare function buildMessage(command: any, payload?: any): any[];
 export declare function getMessageData(command: any): any[];
 export declare function hexstr(arr: any, start?: any, len?: any): string;
-export declare function getHex(i: any): string;
-export declare function append(cmd: any, arr: any): void;
 export declare function ascii(c: any): any;
-export declare function charArrayToString(arr: any): string;
-export declare function asciiArrayToString(arr: any): string;
 export declare function getAsciiArrayFromStr(str: any): any[];
-export declare function Float32ToHex(float32: any): any;
-export declare function Float32ToIntArray(float32: any): any[];
-export declare function Int16ToIntArray(int16: any): any[];
-export declare function Int32ToIntArray(int32: any): any[];
 export declare enum ReservedCommands {
     RESULT_RESET = 0,
     RESULT_GET = 1,
@@ -43,8 +35,12 @@ export declare enum BikeType {
     MOUNTAIN = 2
 }
 export declare function getBikeType(bikeTypeStr?: string): BikeType;
+export declare const FileTimeSupport: {
+    fromCurrentDate: () => any;
+    fromDate: (date: Date) => any;
+};
 export declare function routeToEpp(route: Route, date?: Date): Uint8Array;
-export declare function parseTrainingData(payload: any): {
+export declare function parseTrainingData(payload: string): {
     time: number;
     heartrate: number;
     speed: number;
@@ -60,3 +56,4 @@ export declare function parseTrainingData(payload: any): {
     speedStatus: string;
 };
 export declare function getPersonData(user: User): Buffer;
+export declare function parsePersonData(buffer: Buffer): User;

package/lib/{daum → serial/daum}/premium/utils.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPersonData = exports.parseTrainingData = exports.routeToEpp = exports.getBikeType = exports.BikeType = exports.ReservedCommands = exports.Int32ToIntArray = exports.Int16ToIntArray = exports.Float32ToIntArray = exports.Float32ToHex = exports.getAsciiArrayFromStr = exports.asciiArrayToString = exports.charArrayToString = exports.ascii = exports.append = exports.getHex = exports.hexstr = exports.getMessageData = exports.buildMessage = exports.checkSum = exports.esc2bin = exports.bin2esc = void 0;
+exports.parsePersonData = exports.getPersonData = exports.parseTrainingData = exports.routeToEpp = exports.FileTimeSupport = exports.getBikeType = exports.BikeType = exports.ReservedCommands = exports.getAsciiArrayFromStr = exports.ascii = exports.hexstr = exports.getMessageData = exports.buildMessage = exports.checkSum = exports.esc2bin = exports.bin2esc = void 0;
+const user_1 = require("../../../types/user");
 const win32filetime_1 = __importDefault(require("win32filetime"));
 const sum = (arr) => arr.reduce((a, b) => a + b, 0);
 function bin2esc(arr) {
@@ -145,32 +146,12 @@ function hexstr(arr, start, len) {
     return str;
 }
 exports.hexstr = hexstr;
-function getHex(i) { return ('00' + i.toString(16)).slice(-2); }
-exports.getHex = getHex;
-function append(cmd, arr) { cmd.push(...arr); }
-exports.append = append;
 function ascii(c) {
     if (c === undefined || c === null)
         return;
     return c.charCodeAt(0);
 }
 exports.ascii = ascii;
-function charArrayToString(arr) {
-    if (arr === undefined || arr == null)
-        return undefined;
-    let str = '';
-    arr.forEach(c => str += c);
-    return str;
-}
-exports.charArrayToString = charArrayToString;
-function asciiArrayToString(arr) {
-    if (arr === undefined || arr == null)
-        return undefined;
-    let str = '';
-    arr.forEach(c => str += String.fromCharCode(c));
-    return str;
-}
-exports.asciiArrayToString = asciiArrayToString;
 function getAsciiArrayFromStr(str) {
     if (str === undefined || str === null)
         return undefined;
@@ -182,42 +163,6 @@ function getAsciiArrayFromStr(str) {
     return result;
 }
 exports.getAsciiArrayFromStr = getAsciiArrayFromStr;
-function Float32ToHex(float32) {
-    var view = new DataView(new ArrayBuffer(4));
-    view.setFloat32(0, float32);
-    return Array.apply(null, { length: 4 }).map((_, i) => getHex(view.getUint8(i))).join('');
-}
-exports.Float32ToHex = Float32ToHex;
-function Float32ToIntArray(float32) {
-    var view = new DataView(new ArrayBuffer(4));
-    view.setFloat32(0, float32);
-    var arr = [];
-    for (let i = 0; i < 4; i++) {
-        arr.push(view.getUint8(i));
-    }
-    return arr;
-}
-exports.Float32ToIntArray = Float32ToIntArray;
-function Int16ToIntArray(int16) {
-    var view = new DataView(new ArrayBuffer(2));
-    view.setInt16(0, int16);
-    var arr = [];
-    for (let i = 0; i < 2; i++) {
-        arr.push(view.getUint8(i));
-    }
-    return arr;
-}
-exports.Int16ToIntArray = Int16ToIntArray;
-function Int32ToIntArray(int32) {
-    var view = new DataView(new ArrayBuffer(4));
-    view.setInt32(0, int32);
-    var arr = [];
-    for (let i = 0; i < 4; i++) {
-        arr.push(view.getUint8(i));
-    }
-    return arr;
-}
-exports.Int32ToIntArray = Int32ToIntArray;
 var ReservedCommands;
 (function (ReservedCommands) {
     ReservedCommands[ReservedCommands["RESULT_RESET"] = 0] = "RESULT_RESET";
@@ -253,14 +198,18 @@ function getBikeType(bikeTypeStr) {
     return BikeType.RACE;
 }
 exports.getBikeType = getBikeType;
+exports.FileTimeSupport = {
+    fromCurrentDate: () => win32filetime_1.default.fromUnix(Date.now()),
+    fromDate: (date) => win32filetime_1.default.fromUnix(date),
+};
 function routeToEpp(route, date) {
     const buffer = Buffer.alloc(376 + route.points.length * 12);
-    const fileTime = win32filetime_1.default.fromUnix(date ? date : Date.now());
+    const fileTime = date ? exports.FileTimeSupport.fromDate(date) : exports.FileTimeSupport.fromCurrentDate();
     let offset = 0;
     const name = route.name || '';
     const description = route.description || '';
     const minElevation = route.minElevation ? route.minElevation : 0;
-    const maxElevation = route.maxElevation ? route.minElevation : Math.max(...route.points.map(p => p.elevation));
+    const maxElevation = route.maxElevation ? route.maxElevation : route.points.length > 0 ? Math.max(...route.points.map(p => p.elevation)) : minElevation;
     const sampleRate = route.points.length !== 0 ? Math.round(route.totalDistance / route.points.length) : 0;
     buffer.writeUInt32LE(fileTime.low, offset);
     offset += 4;
@@ -359,13 +308,13 @@ function getPersonData(user) {
         buffer.writeUInt8(0, offset);
         offset += 1;
     }
-    buffer.writeInt32LE(1, offset);
+    buffer.writeInt32LE(user && user.sex === user_1.Gender.FEMALE ? 2 : 1, offset);
     offset += 4;
-    buffer.writeInt32LE(1, offset);
+    buffer.writeInt32LE(user && user.age !== undefined ? user.age : 1, offset);
     offset += 4;
-    buffer.writeInt32LE(175, offset);
+    buffer.writeInt32LE(user && user.length !== undefined ? user.length : 175, offset);
     offset += 4;
-    buffer.writeFloatLE(70, offset);
+    buffer.writeFloatLE(user && user.weight !== undefined ? user.weight : 70, offset);
     offset += 4;
     buffer.writeFloatLE(0, offset);
     offset += 4;
@@ -374,3 +323,13 @@ function getPersonData(user) {
     return buffer;
 }
 exports.getPersonData = getPersonData;
+function parsePersonData(buffer) {
+    const valSex = buffer.readInt32LE(112);
+    const valAge = buffer.readInt32LE(116);
+    const length = buffer.readInt32LE(120);
+    const weight = buffer.readFloatLE(124);
+    const age = valAge > 1 ? valAge : undefined;
+    const sex = valSex === 2 ? user_1.Gender.FEMALE : user_1.Gender.MALE;
+    return { length, weight, age, sex };
+}
+exports.parsePersonData = parsePersonData;

package/lib/serial/index.d.ts

@@ -0,0 +1,9 @@
+import SerialPortProvider, { useSerialPortProvider } from './serialport';
+import SerialInterface, { SerialInterfaceProps } from './serial-interface';
+import SerialAdapterFactory from './adapter-factory';
+import { SerialIncyclistDevice, SerialDeviceSettings } from './adapter';
+import DaumClassicAdapter from './daum/classic/adapter';
+import DaumPremiumAdapter from './daum/premium/adapter';
+import KettlerRacerAdapter from './kettler/ergo-racer/adapter';
+export { TCPBinding } from './bindings/tcp';
+export { SerialPortProvider, useSerialPortProvider, SerialInterface, SerialInterfaceProps, SerialDeviceSettings, SerialAdapterFactory, DaumClassicAdapter, DaumPremiumAdapter, KettlerRacerAdapter, SerialIncyclistDevice };

package/lib/serial/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerialIncyclistDevice = exports.KettlerRacerAdapter = exports.DaumPremiumAdapter = exports.DaumClassicAdapter = exports.SerialAdapterFactory = exports.SerialInterface = exports.useSerialPortProvider = exports.SerialPortProvider = exports.TCPBinding = void 0;
+const serialport_1 = __importStar(require("./serialport"));
+exports.SerialPortProvider = serialport_1.default;
+Object.defineProperty(exports, "useSerialPortProvider", { enumerable: true, get: function () { return serialport_1.useSerialPortProvider; } });
+const serial_interface_1 = __importDefault(require("./serial-interface"));
+exports.SerialInterface = serial_interface_1.default;
+const adapter_factory_1 = __importDefault(require("./adapter-factory"));
+exports.SerialAdapterFactory = adapter_factory_1.default;
+const adapter_1 = require("./adapter");
+Object.defineProperty(exports, "SerialIncyclistDevice", { enumerable: true, get: function () { return adapter_1.SerialIncyclistDevice; } });
+const adapter_2 = __importDefault(require("./daum/classic/adapter"));
+exports.DaumClassicAdapter = adapter_2.default;
+const adapter_3 = __importDefault(require("./daum/premium/adapter"));
+exports.DaumPremiumAdapter = adapter_3.default;
+const adapter_4 = __importDefault(require("./kettler/ergo-racer/adapter"));
+exports.KettlerRacerAdapter = adapter_4.default;
+var tcp_1 = require("./bindings/tcp");
+Object.defineProperty(exports, "TCPBinding", { enumerable: true, get: function () { return tcp_1.TCPBinding; } });
+adapter_factory_1.default.getInstance().registerAdapter('Daum Classic', adapter_2.default);
+adapter_factory_1.default.getInstance().registerAdapter('Daum Premium', adapter_3.default);
+adapter_factory_1.default.getInstance().registerAdapter('Kettler Racer', adapter_4.default);