incyclist-devices 1.4.0 → 1.4.3

package/lib/CyclingMode.d.ts

@@ -52,10 +52,13 @@ export default interface CyclingMode {
     setSetting(name: string, value: any): void;
     getSetting(name: string): any;
     getSettings(): Settings;
+    setModeProperty(name: string, value: any): void;
+    getModeProperty(name: string): any;
 }
 export declare class CyclingModeBase implements CyclingMode {
     adapter: Device;
     settings: Settings;
+    properties: Settings;
     constructor(adapter: Device, props?: any);
     setAdapter(adapter: Device): void;
     getBikeInitRequest(): UpdateRequest;
@@ -69,4 +72,6 @@ export declare class CyclingModeBase implements CyclingMode {
     setSetting(name: string, value: any): void;
     getSetting(name: string): any;
     getSettings(): Settings;
+    setModeProperty(name: string, value: any): void;
+    getModeProperty(name: string): any;
 }

package/lib/CyclingMode.js

@@ -13,6 +13,7 @@ var CyclingModeProperyType;
 class CyclingModeBase {
     constructor(adapter, props) {
         this.settings = {};
+        this.properties = {};
         if (!adapter)
             throw new Error('IllegalArgument: adapter is null');
         this.setAdapter(adapter);
@@ -62,5 +63,17 @@ class CyclingModeBase {
     getSettings() {
         return this.settings;
     }
+    setModeProperty(name, value) {
+        this.properties[name] = value;
+    }
+    getModeProperty(name) {
+        const res = this.properties[name];
+        if (res !== undefined)
+            return res;
+        const prop = this.getProperties().find(p => p.key === name);
+        if (prop && prop.default !== undefined)
+            return prop.default;
+        return undefined;
+    }
 }
 exports.CyclingModeBase = CyclingModeBase;

package/lib/ant/AntScanner.js

@@ -575,8 +575,6 @@ class AntProtocol extends DeviceProtocol_1.default {
                             const channel = channelsUsed + idx;
                             const { sensor } = i;
                             i.device.setChannel(channel);
-                            if (process.env.DEBUG)
-                                console.log('~~~~Ant: attach', channel, i.device.getID());
                             sensor.attach(channel, i.device.getID());
                             this.sensors.attached.push(i);
                         });

package/lib/ant/antfe/AntFEAdapter.js

@@ -176,8 +176,9 @@ class AntFEAdapter extends AntAdapter_1.default {
         });
         return __awaiter(this, void 0, void 0, function* () {
             yield _super.start.call(this, props);
-            this.logger.logEvent({ message: 'start()' });
-            const args = props || {};
+            this.logger.logEvent({ message: 'start()', props });
+            const opts = props || {};
+            const { args } = opts;
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 if (this.ignoreHrm && this.ignoreBike && this.ignorePower) {
                     this.logger.logEvent({ message: 'start() not done: bike disabled' });

package/lib/daum/DaumAdapter.d.ts

@@ -1,6 +1,7 @@
 import { EventLogger } from 'gd-eventlog';
 import CyclingMode from '../CyclingMode';
 import DeviceAdapterBase, { Bike, DeviceAdapter } from '../Device';
+import { User } from '../types/user';
 interface DaumAdapter {
     getCurrentBikeData(): Promise<any>;
 }
@@ -18,7 +19,7 @@ export default class DaumAdapterBase extends DeviceAdapterBase implements Device
     iv: any;
     logger: EventLogger;
     cyclingMode: CyclingMode;
-    userSettings: any;
+    userSettings: User;
     bikeSettings: any;
     tsPrevData: number;
     adapterTime: number;
@@ -29,7 +30,7 @@ export default class DaumAdapterBase extends DeviceAdapterBase implements Device
     getSupportedCyclingModes(): Array<any>;
     getCyclingMode(): CyclingMode;
     getDefaultCyclingMode(): CyclingMode;
-    setUserSettings(userSettings: any): void;
+    setUserSettings(userSettings: User): void;
     setBikeSettings(bikeSettings: any): void;
     getWeight(): number;
     getCurrentBikeData(): Promise<any>;

package/lib/daum/ERGCyclingMode.js

@@ -11,7 +11,7 @@ const config = {
     description: "Calculates speed based on power and slope. Power is either set by workout or calculated based on gear and cadence",
     properties: [
         { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
-        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of raining', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
+        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
     ]
 };
 class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {

package/lib/daum/SmartTrainerCyclingMode.js

@@ -13,7 +13,7 @@ const config = {
     description: "Calculates power based on speed and slope.",
     properties: [
         { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
-        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of raining', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50 },
+        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50 },
         { key: 'minPower', name: 'Minimum Power', description: 'Minimum power in declines', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50 },
         { key: 'simulation', name: 'Simulate ', description: 'Simulate ', type: CyclingMode_1.CyclingModeProperyType.Boolean, default: false },
         { key: 'chainRings', name: 'Chain Rings', description: 'Simulated chain rings (format: <min>-<max>)', type: CyclingMode_1.CyclingModeProperyType.String, validation: '', default: '36-52', condition: (s) => s.simulation },

package/lib/daum/classic/DaumClassicAdapter.js

@@ -83,7 +83,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'start()', props });
             const opts = props || {};
-            const person = props;
+            const { user } = props;
             this.initData();
             let startState = {};
             return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
@@ -96,7 +96,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                         startState.setProg = true;
                     }
                     if (!startState.setPerson) {
-                        yield this.getBike().setPerson({ person });
+                        yield this.getBike().setPerson(user);
                         startState.setPerson = true;
                     }
                     if (!startState.startProg) {

package/lib/daum/classic/DaumClassicProtocol.js

@@ -156,7 +156,7 @@ class DaumClassicProtocol extends DeviceProtocol_1.default {
             return;
         scan.scanning = true;
         return device.check()
-            .then(() => {
+            .then(() => __awaiter(this, void 0, void 0, function* () {
             if (this.state.stopScanning)
                 return;
             const { onDeviceFound, onScanFinished, id } = opts;
@@ -166,10 +166,16 @@ class DaumClassicProtocol extends DeviceProtocol_1.default {
             if (onScanFinished) {
                 onScanFinished(id);
             }
+            try {
+                yield device.getBike().saveClose();
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'scanCommand warning: Could not close port', error: err.message });
+            }
             clearInterval(scan.iv);
             scan.iv = undefined;
             scan.scanning = false;
-        })
+        }))
             .catch(() => {
             scan.scanning = false;
         });

package/lib/daum/classic/bike.d.ts

@@ -1,5 +1,6 @@
 import { EventLogger } from 'gd-eventlog';
 import { Queue } from '../../utils';
+import { User } from '../../types/user';
 declare type SuccessCallbackFn = (data: any) => void;
 declare type ErrorCallbackFn = (status: number, error: any) => void;
 interface CommandInstructions {
@@ -32,7 +33,7 @@ export default class Daum8008 {
     getType(): string;
     getPort(): string;
     isConnected(): boolean;
-    setUser(user: any, callback: any): void;
+    setUser(user: User, callback: any): void;
     getUserWeight(): number;
     getBikeWeight(): any;
     connect(): void;
@@ -54,7 +55,7 @@ export default class Daum8008 {
     stopProg(bikeNo?: number): Promise<unknown>;
     setProg(progNo?: number, bikeNo?: number): Promise<unknown>;
     setBikeType(bikeType: any, bikeNo?: number): Promise<unknown>;
-    setPerson(user?: any, bikeNo?: number): Promise<unknown>;
+    setPerson(user?: User, bikeNo?: number): Promise<unknown>;
     runData(bikeNo?: number): Promise<unknown>;
     setGear(gear: any, bikeNo?: number): Promise<unknown>;
     setPower(power: any, bikeNo?: number): Promise<unknown>;

package/lib/daum/classic/bike.js

@@ -15,8 +15,8 @@ class Daum8008 {
         this.portName = opts.port || process.env.COM_PORT;
         this.settings = opts.settings || {};
         this.bikeData = {
-            userWeight: 75,
-            bikeWeight: 10,
+            userWeight: utils_1.DEFAULT_USER_WEIGHT,
+            bikeWeight: utils_1.DEFAULT_BIKE_WEIGHT,
             maxPower: 800
         };
         this.sp = undefined;
@@ -45,7 +45,8 @@ class Daum8008 {
     }
     setUser(user, callback) {
         this.logger.logEvent({ message: "setUser()", user });
-        this.settings.user = user || {};
+        if (user)
+            this.settings.user = user;
         var cb = callback || nop;
         cb(200, user);
     }
@@ -361,7 +362,7 @@ class Daum8008 {
         });
     }
     setPerson(user = {}, bikeNo = 0) {
-        const age = user.age !== undefined ? user.age : (0, utils_1.getAge)(user.birthday);
+        const age = user.age !== undefined ? user.age : utils_1.DEFAULT_AGE;
         const gender = (0, utils_1.getGender)(user.sex);
         const length = (0, utils_1.getLength)(user.length);
         const maxPower = this.settings.maxPower === undefined ? 800 : this.settings.maxPower;

package/lib/daum/classic/utils.d.ts

@@ -1,6 +1,8 @@
-export declare function getCockpit(c: any): "Cardio" | "Fitness" | "Vita De Luxe" | "8008" | "8080" | "Therapie" | "8008 TRS Pro" | "8008 TRS3" | "Unknown";
+export declare const DEFAULT_AGE = 30;
+export declare const DEFAULT_USER_WEIGHT = 75;
+export declare const DEFAULT_BIKE_WEIGHT = 10;
+export declare function getCockpit(c: any): "Cardio" | "Fitness" | "Vita De Luxe" | "8008" | "8008 TRS" | "8080" | "Therapie" | "8008 TRS Pro" | "8008 TRS3" | "Unknown";
 export declare function getBikeType(type: any): 1 | 0;
-export declare function getAge(birthday: any): number;
 export declare function getGender(sex: any): 1 | 2;
 export declare function getLength(length: any): number;
 export declare function getWeight(weight?: any): number;

package/lib/daum/classic/utils.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Float32ToIntArray = exports.Float32ToHex = exports.hexstr = exports.buildError = exports.parseRunData = exports.getWeight = exports.getLength = exports.getGender = exports.getAge = exports.getBikeType = exports.getCockpit = void 0;
+exports.Float32ToIntArray = exports.Float32ToHex = exports.hexstr = exports.buildError = exports.parseRunData = exports.getWeight = exports.getLength = exports.getGender = exports.getBikeType = exports.getCockpit = exports.DEFAULT_BIKE_WEIGHT = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_AGE = void 0;
+exports.DEFAULT_AGE = 30;
+exports.DEFAULT_USER_WEIGHT = 75;
+exports.DEFAULT_BIKE_WEIGHT = 10;
 function getCockpit(c) {
     switch (c) {
         case 10:
@@ -11,6 +14,8 @@ function getCockpit(c) {
             return "Vita De Luxe";
         case 40:
             return "8008";
+        case 0x2A:
+            return "8008 TRS";
         case 50:
             return "8080";
         case 60:
@@ -39,21 +44,6 @@ function getBikeType(type) {
     }
 }
 exports.getBikeType = getBikeType;
-function getAge(birthday) {
-    if (birthday === undefined) {
-        return 30;
-    }
-    try {
-        const bd = new Date(birthday);
-        const ageDifMs = Date.now() - bd.getTime();
-        var ageDate = new Date(ageDifMs);
-        return Math.abs(ageDate.getUTCFullYear() - 1970);
-    }
-    catch (error) {
-        return 30;
-    }
-}
-exports.getAge = getAge;
 function getGender(sex) {
     if (sex === undefined)
         return 2;

package/lib/daum/premium/DaumClassicCyclingMode.d.ts

@@ -0,0 +1,14 @@
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "../../CyclingMode";
+import DaumAdapter from "../DaumAdapter";
+import PowerMeterCyclingMode from "../PowerMeterCyclingMode";
+export default class DaumClassicCyclingMode extends PowerMeterCyclingMode implements CyclingMode {
+    constructor(adapter: DaumAdapter, props?: Settings);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    getSettings(): Settings;
+    getSetting(name: string): any;
+    updateData(data: IncyclistBikeData): IncyclistBikeData;
+}

package/lib/daum/premium/DaumClassicCyclingMode.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gd_eventlog_1 = require("gd-eventlog");
+const CyclingMode_1 = require("../../CyclingMode");
+const PowerMeterCyclingMode_1 = __importDefault(require("../PowerMeterCyclingMode"));
+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",
+    properties: [
+        { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain'], default: 'Race' },
+    ]
+};
+class DaumClassicCyclingMode extends PowerMeterCyclingMode_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.logger = adapter ? adapter.logger : undefined;
+        if (!this.logger)
+            this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
+        this.setModeProperty('eppSupport', true);
+        this.setModeProperty('setPersonSupport', true);
+    }
+    getName() {
+        return config.name;
+    }
+    getDescription() {
+        return config.description;
+    }
+    getProperties() {
+        return config.properties;
+    }
+    getProperty(name) {
+        return config.properties.find(p => p.name === name);
+    }
+    getBikeInitRequest() {
+        return {};
+    }
+    getSettings() {
+        const settings = super.getSettings();
+        settings['setPerson'] = true;
+        return settings;
+    }
+    getSetting(name) {
+        if (name === 'setPerson')
+            return true;
+        return super.getSetting(name);
+    }
+    updateData(data) {
+        try {
+            const prevData = this.data || {};
+            const prevRequest = this.prevRequest || {};
+            const bikeData = JSON.parse(JSON.stringify(data));
+            let power = data.power || 0;
+            let speed = data.speed || 0;
+            let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            let distanceBike = data.distanceInternal || 0;
+            let distancePrev = prevData.distanceInternal || 0;
+            let distanceInternal = distanceBike;
+            let ts = Date.now();
+            if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
+                speed = 0;
+                power = 0;
+            }
+            if (distanceBike < distancePrev) {
+                let v = speed / 3.6;
+                let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
+                distanceInternal = distancePrev + Math.round(v * duration);
+            }
+            data.speed = parseFloat(speed.toFixed(1));
+            data.power = Math.round(power);
+            data.distanceInternal = Math.round(distanceInternal);
+            data.distance = Math.round(distanceInternal / 100);
+            data.slope = slope;
+            this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest: {}, prevSpeed: prevData.speed });
+            this.data = JSON.parse(JSON.stringify(data));
+            this.prevUpdateTS = ts;
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
+        }
+        return data;
+    }
+}
+exports.default = DaumClassicCyclingMode;

package/lib/daum/premium/DaumPremiumAdapter.d.ts

@@ -1,3 +1,4 @@
+import { Route } from '../../types/route';
 import DaumAdapter from '../DaumAdapter';
 export default class DaumPremiumDevice extends DaumAdapter {
     static NAME: string;
@@ -5,7 +6,9 @@ export default class DaumPremiumDevice extends DaumAdapter {
     getName(): string;
     getPort(): any;
     getInterface(): any;
+    getSupportedCyclingModes(): Array<any>;
     check(): Promise<unknown>;
+    initClassic(route: Route): Promise<boolean>;
     start(props: any): Promise<unknown>;
     getCurrentBikeData(): Promise<any>;
 }

package/lib/daum/premium/DaumPremiumAdapter.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("../../utils");
 const DaumAdapter_1 = __importDefault(require("../DaumAdapter"));
+const DaumClassicCyclingMode_1 = __importDefault(require("./DaumClassicCyclingMode"));
 const PROTOCOL_NAME = "Daum Premium";
 class DaumPremiumDevice extends DaumAdapter_1.default {
     constructor(protocol, bike) {
@@ -38,6 +39,11 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
     getInterface() {
         return this.bike.getInterface();
     }
+    getSupportedCyclingModes() {
+        const supported = super.getSupportedCyclingModes();
+        supported.push(DaumClassicCyclingMode_1.default);
+        return supported;
+    }
     check() {
         var info = {};
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -56,10 +62,28 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             }
         }));
     }
+    initClassic(route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!route)
+                return true;
+            let res;
+            const bikeType = this.getCyclingMode().getSetting('bikeType');
+            res = yield this.bike.programUpload(bikeType, route);
+            if (!res)
+                return false;
+            res = yield this.bike.startProgram(route.programId);
+            if (!res)
+                return false;
+        });
+    }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'start()', props });
+            this.logger.logEvent({ message: 'start()' });
+            console.log('~~~setPersonSupport:', this.getCyclingMode().getModeProperty('setPersonSupport'));
+            console.log('~~~eppSupport:', this.getCyclingMode().getModeProperty('eppSupport'));
             const opts = props || {};
+            const user = opts.user || this.userSettings;
+            const route = opts.route;
             var info = {};
             this.initData();
             return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
@@ -75,10 +99,23 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
                     if (!info.version) {
                         info.version = yield this.bike.getProtocolVersion();
                     }
+                    if (!info.init && this.getCyclingMode().getModeProperty('setPersonSupport')) {
+                        info.init = yield this.initClassic(route);
+                    }
+                    else {
+                        info.init = true;
+                    }
+                    if (!info.person && this.getCyclingMode().getModeProperty('eppSupport')) {
+                        info.person = yield this.bike.setPerson(user);
+                    }
+                    else {
+                        info.person = true;
+                    }
                     const gear = yield this.bike.setGear(this.data.gear || (opts.gear || 10));
                     return gear;
                 }
                 catch (err) {
+                    console.error(err);
                     throw (new Error(`could not start device, reason:${err.message}`));
                 }
             }), 5, 1000)

package/lib/daum/premium/DaumPremiumProtocol.js

@@ -177,7 +177,7 @@ class DaumPremiumProtocol extends DeviceProtocol_1.default {
             return;
         scan.scanning = true;
         device.check()
-            .then(() => {
+            .then(() => __awaiter(this, void 0, void 0, function* () {
             if (this.state.stopScanning)
                 return;
             const { onDeviceFound, onScanFinished, id } = opts;
@@ -187,10 +187,16 @@ class DaumPremiumProtocol extends DeviceProtocol_1.default {
             if (onScanFinished) {
                 onScanFinished(id);
             }
+            try {
+                yield device.getBike().saveClose();
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'scanCommand warning: Could not close port', error: err.message });
+            }
             clearInterval(scan.iv);
             scan.iv = undefined;
             scan.scanning = false;
-        })
+        }))
             .catch(() => {
             scan.scanning = false;
         });

package/lib/daum/premium/bike.d.ts

@@ -1,5 +1,9 @@
+/// <reference types="node" />
+import { ReservedCommands, BikeType } from './utils';
 import { Queue } from '../../utils';
 import { EventLogger } from 'gd-eventlog';
+import { User } from "../../types/user";
+import { Route } from "../../types/route";
 declare class Daum8i {
     portName: string;
     logger: EventLogger;
@@ -63,7 +67,7 @@ declare class Daum8i {
     sendDaum8iCommand(command: any, queryType: any, payload: any): Promise<unknown>;
     sendACK(): void;
     sendNAK(): void;
-    sendReservedDaum8iCommand(command: any, cmdType: any, data: any): Promise<any[]>;
+    sendReservedDaum8iCommand(command: ReservedCommands, cmdType: any, data?: Buffer): Promise<any[]>;
     getProtocolVersion(): Promise<string>;
     getDashboardVersion(): Promise<unknown>;
     getDeviceType(): Promise<any>;
@@ -89,7 +93,13 @@ declare class Daum8i {
     setSlope(slope: any): void;
     setPower(power: any): Promise<number>;
     getPower(power: any): Promise<number>;
-    setPerson(person: any): Promise<any[]>;
+    setPerson(person: User): Promise<boolean>;
+    programUploadInit(): Promise<boolean>;
+    programUploadStart(bikeType: BikeType, route: Route): Promise<Uint8Array>;
+    programUploadSendBlock(epp: Uint8Array, offset: number): Promise<boolean>;
+    programUploadDone(): Promise<boolean>;
+    programUpload(bikeType: BikeType, route: Route): Promise<boolean>;
+    startProgram(programId?: number): Promise<boolean>;
     setGear(gear: any): Promise<number>;
     getGear(): Promise<number>;
 }

package/lib/daum/premium/bike.js

@@ -25,6 +25,7 @@ const TIMEOUT_START = 15000;
 const OPEN_TIMEOUT = 1000;
 const DAUM_PREMIUM_DEFAULT_PORT = 51955;
 const DAUM_PREMIUM_DEFAULT_HOST = '127.0.0.1';
+const MAX_DATA_BLOCK_SIZE = 512;
 var __SerialPort = undefined;
 var net = undefined;
 const DEBUG_LOGGER = {
@@ -166,21 +167,18 @@ class Daum8i {
             const tTimeout = Date.now() + TIMEOUT_START;
             const iv = setInterval(() => {
                 if (this.state.error !== undefined) {
-                    console.log('~~ -> error');
                     clearInterval(iv);
                     this.forceClose();
                     reject(this.state.error);
                     this.state = { opened: false, closed: true, busy: false };
                 }
                 else if (this.isConnected()) {
-                    console.log('~~ -> connected');
                     this.state.connecting = false;
                     resolve(true);
                     clearInterval(iv);
                 }
                 else {
                     if (Date.now() > tTimeout) {
-                        console.log('~~ -> timeout');
                         this.state.connecting = false;
                         this.forceClose();
                         clearInterval(iv);
@@ -281,7 +279,6 @@ class Daum8i {
         });
     }
     forceClose(updateState = false) {
-        console.log('~~~ forceClose', updateState);
         const sp = this.sp;
         if (!this.sp)
             return;
@@ -578,20 +575,23 @@ class Daum8i {
         this.logger.logEvent({ message: "sendCommand:sending NAK", port });
     }
     sendReservedDaum8iCommand(command, cmdType, data) {
-        let cmdData = [];
-        const key = (0, utils_1.getReservedCommandKey)(command);
-        (0, utils_1.append)(cmdData, (0, utils_1.Int16ToIntArray)(key));
+        let buffer;
         if (data !== undefined && data.length > 0) {
-            (0, utils_1.append)(cmdData, (0, utils_1.Int16ToIntArray)(data.length));
-            (0, utils_1.append)(cmdData, data);
+            buffer = Buffer.alloc(data.length + 4);
+            buffer.writeInt16LE(command, 0);
+            buffer.writeUInt16LE(data.length, 2);
+            data.copy(buffer, 4);
         }
         else {
-            (0, utils_1.append)(cmdData, (0, utils_1.Int16ToIntArray)(0));
+            buffer = Buffer.alloc(4);
+            buffer.writeInt16LE(command, 0);
+            buffer.writeUInt16LE(0, 2);
         }
+        const cmdData = Uint8Array.from(buffer);
         return this.sendDaum8iCommand('M70', cmdType, (0, utils_1.bin2esc)(cmdData))
-            .then((resData) => {
+            .then((res) => {
+            const resData = Uint8Array.from(res, x => x.charCodeAt(0));
             const cmd = (0, utils_1.esc2bin)(resData);
-            cmd.splice(0, 4);
             return cmd;
         });
     }
@@ -710,7 +710,99 @@ class Daum8i {
         });
     }
     setPerson(person) {
-        return this.sendReservedDaum8iCommand('PERSON_SET', 'BF', person.getData());
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PERSON_SET, 'BF', (0, utils_1.getPersonData)(person))
+            .then((res) => {
+            const buffer = Buffer.from(res);
+            return buffer.readInt16LE(0) === utils_1.ReservedCommands.PERSON_SET;
+        });
+    }
+    programUploadInit() {
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_BEGIN, 'BF')
+            .then((res) => {
+            const buffer = Buffer.from(res);
+            return buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_BEGIN;
+        });
+    }
+    programUploadStart(bikeType, route) {
+        const payload = Buffer.alloc(40);
+        const epp = (0, utils_1.routeToEpp)(route);
+        payload.writeInt32LE(0, 0);
+        payload.writeInt8(bikeType, 4);
+        payload.writeInt8(bikeType, 5);
+        payload.writeInt16LE(0, 6);
+        payload.writeInt32LE(0, 8);
+        payload.writeInt32LE(0, 12);
+        payload.writeFloatLE(0, 16);
+        payload.writeFloatLE(0, 20);
+        payload.writeInt16LE(0, 24);
+        payload.writeInt16LE(0, 26);
+        payload.writeInt16LE(0, 28);
+        payload.writeInt16LE(0, 30);
+        payload.writeInt32LE(7, 32);
+        payload.writeInt32LE(epp.length, 36);
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM, 'BF', payload)
+            .then((res) => {
+            const buffer = Buffer.from(res);
+            if (buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM) {
+                return epp;
+            }
+            throw new Error('Illegal Response');
+        });
+    }
+    programUploadSendBlock(epp, offset) {
+        const remaining = epp.length - offset;
+        if (remaining <= 0)
+            return Promise.resolve(true);
+        const size = remaining > MAX_DATA_BLOCK_SIZE ? MAX_DATA_BLOCK_SIZE : remaining;
+        const payload = Buffer.alloc(size + 8);
+        payload.writeInt32LE(size, 0);
+        payload.writeInt32LE(offset, 4);
+        const chunk = Buffer.from(epp.slice(offset, offset + size));
+        chunk.copy(payload, 8);
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM, 'BF', payload)
+            .then((res) => {
+            const buffer = Buffer.from(res);
+            let success = buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM;
+            success = success && (buffer.readInt16LE(2) === 1);
+            success = success && (buffer.readInt8(4) === 1);
+            if (!success)
+                throw new Error('Illegal Response');
+            return success;
+        });
+    }
+    programUploadDone() {
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_END, 'BF')
+            .then((res) => {
+            const buffer = Buffer.from(res);
+            return buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_END;
+        });
+    }
+    programUpload(bikeType, route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.programUploadInit();
+            const epp = yield this.programUploadStart(bikeType, route);
+            let success = true;
+            let done = false;
+            let offset = 0;
+            while (success && !done) {
+                success = yield this.programUploadSendBlock(epp, offset);
+                offset += MAX_DATA_BLOCK_SIZE;
+                done = offset >= epp.length;
+            }
+            if (done) {
+                return yield this.programUploadDone();
+            }
+            return false;
+        });
+    }
+    startProgram(programId = 1) {
+        const payload = Buffer.alloc(2);
+        payload.writeInt16LE(programId, 0);
+        return this.sendReservedDaum8iCommand(utils_1.ReservedCommands.PROGRAM_LIST_START, 'BF', payload)
+            .then((res) => {
+            const buffer = Buffer.from(res);
+            return buffer.readInt16LE(0) === utils_1.ReservedCommands.PROGRAM_LIST_START;
+        });
     }
     setGear(gear) {
         return this.sendDaum8iCommand('M71', 'BF', `${gear}`)

package/lib/daum/premium/tcpserial.js

@@ -38,18 +38,15 @@ class TcpSocketPort {
                 });
             }
             this.logger.logEvent({ message: 'opening', id: this.id, retry });
-            console.log('~~opening socket', this.id);
             this.socket.connect(this.port, this.host);
         }
         catch (err) {
             this.logger.logEvent({ message: 'opening error', id: this.id, error: err.message, stack: err.stack });
-            console.log('~~open socket error', this.id, err);
             this.emit('error', err);
         }
     }
     close() {
         this.logger.logEvent({ message: 'closing', id: this.id });
-        console.log('~~closing socket', this.id);
         this.isOpen = false;
         this.isClosed = true;
         try {
@@ -67,7 +64,6 @@ class TcpSocketPort {
         if (this.isOpen)
             return;
         this.logger.logEvent({ message: 'timeout', id: this.id });
-        console.log('~~socket timeout', this.id);
         try {
             this.socket.end();
         }
@@ -78,14 +74,12 @@ class TcpSocketPort {
     }
     onConnect() {
         this.logger.logEvent({ message: 'connected', id: this.id });
-        console.log('~~socket connected', this.id);
         this.isOpen = true;
         this.isClosed = false;
         this.emit('open');
     }
     onError(err) {
         this.logger.logEvent({ message: 'error', error: err.message });
-        console.log('~~socket error', this.id, err);
         if (this.callbacks['error'])
             this.callbacks['error'](err);
     }

package/lib/daum/premium/utils.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="node" />
+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;
@@ -14,7 +17,33 @@ 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 function getReservedCommandKey(cmdStr: any): any;
+export declare enum ReservedCommands {
+    RESULT_RESET = 0,
+    RESULT_GET = 1,
+    NETRACE_START = 2,
+    NETRACE_STOP = 3,
+    NETRACE_USERNAME = 4,
+    NETRACE_USERDATA = 5,
+    PERSON_GET = 6,
+    PERSON_SET = 7,
+    PROGRAM_LIST_BEGIN = 8,
+    PROGRAM_LIST_NEW_PROGRAM = 9,
+    PROGRAM_LIST_CONTINUE_PROGRAM = 10,
+    PROGRAM_LIST_END = 11,
+    PROGRAM_LIST_START = 12,
+    RELAX_START = 12,
+    RELAX_STOP = 14,
+    RELAX_GET_DATA = 15,
+    KEY_PRESSED = 16,
+    PROGRAM_CONTROL = 17
+}
+export declare enum BikeType {
+    ALLROUND = 0,
+    RACE = 1,
+    MOUNTAIN = 2
+}
+export declare function getBikeType(bikeTypeStr?: string): BikeType;
+export declare function routeToEpp(route: Route, date?: Date): Uint8Array;
 export declare function parseTrainingData(payload: any): {
     time: number;
     heartrate: number;
@@ -30,3 +59,4 @@ export declare function parseTrainingData(payload: any): {
     deviceState: number;
     speedStatus: string;
 };
+export declare function getPersonData(user: User): Buffer;

package/lib/daum/premium/utils.js

@@ -1,6 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTrainingData = exports.getReservedCommandKey = 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.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;
+const user_1 = require("../../types/user");
+const utils_1 = require("../classic/utils");
+const win32filetime_1 = __importDefault(require("win32filetime"));
 const sum = (arr) => arr.reduce((a, b) => a + b, 0);
 function bin2esc(arr) {
     if (arr === undefined) {
@@ -114,7 +120,7 @@ function getMessageData(command) {
 }
 exports.getMessageData = getMessageData;
 function hexstr(arr, start, len) {
-    const isArr = Array.isArray(arr);
+    const isArr = Array.isArray(arr) || arr instanceof Uint8Array;
     if (!arr)
         return '';
     var str = "";
@@ -211,30 +217,95 @@ function Int32ToIntArray(int32) {
     return arr;
 }
 exports.Int32ToIntArray = Int32ToIntArray;
-const __commands = {
-    RESULT_RESET: 0,
-    RESULT_GET: 1,
-    NETRACE_START: 2,
-    NETRACE_STOP: 3,
-    NETRACE_USERNAME: 4,
-    NETRACE_USERDATA: 5,
-    PERSON_GET: 6,
-    PERSON_SET: 7,
-    PROGRAM_LIST_BEGIN: 8,
-    PROGRAM_LIST_NEW_PROGRAM: 9,
-    PROGRAM_LIST_CONTINUE_PROGRAM: 10,
-    PROGRAM_LIST_END: 11,
-    PROGRAM_LIST_START: 12,
-    RELAX_START: 12,
-    RELAX_STOP: 14,
-    RELAX_GET_DATA: 0xF,
-    KEY_PRESSED: 0x10,
-    PROGRAM_CONTROL: 17
-};
-function getReservedCommandKey(cmdStr) {
-    return __commands[cmdStr];
+var ReservedCommands;
+(function (ReservedCommands) {
+    ReservedCommands[ReservedCommands["RESULT_RESET"] = 0] = "RESULT_RESET";
+    ReservedCommands[ReservedCommands["RESULT_GET"] = 1] = "RESULT_GET";
+    ReservedCommands[ReservedCommands["NETRACE_START"] = 2] = "NETRACE_START";
+    ReservedCommands[ReservedCommands["NETRACE_STOP"] = 3] = "NETRACE_STOP";
+    ReservedCommands[ReservedCommands["NETRACE_USERNAME"] = 4] = "NETRACE_USERNAME";
+    ReservedCommands[ReservedCommands["NETRACE_USERDATA"] = 5] = "NETRACE_USERDATA";
+    ReservedCommands[ReservedCommands["PERSON_GET"] = 6] = "PERSON_GET";
+    ReservedCommands[ReservedCommands["PERSON_SET"] = 7] = "PERSON_SET";
+    ReservedCommands[ReservedCommands["PROGRAM_LIST_BEGIN"] = 8] = "PROGRAM_LIST_BEGIN";
+    ReservedCommands[ReservedCommands["PROGRAM_LIST_NEW_PROGRAM"] = 9] = "PROGRAM_LIST_NEW_PROGRAM";
+    ReservedCommands[ReservedCommands["PROGRAM_LIST_CONTINUE_PROGRAM"] = 10] = "PROGRAM_LIST_CONTINUE_PROGRAM";
+    ReservedCommands[ReservedCommands["PROGRAM_LIST_END"] = 11] = "PROGRAM_LIST_END";
+    ReservedCommands[ReservedCommands["PROGRAM_LIST_START"] = 12] = "PROGRAM_LIST_START";
+    ReservedCommands[ReservedCommands["RELAX_START"] = 12] = "RELAX_START";
+    ReservedCommands[ReservedCommands["RELAX_STOP"] = 14] = "RELAX_STOP";
+    ReservedCommands[ReservedCommands["RELAX_GET_DATA"] = 15] = "RELAX_GET_DATA";
+    ReservedCommands[ReservedCommands["KEY_PRESSED"] = 16] = "KEY_PRESSED";
+    ReservedCommands[ReservedCommands["PROGRAM_CONTROL"] = 17] = "PROGRAM_CONTROL";
+})(ReservedCommands = exports.ReservedCommands || (exports.ReservedCommands = {}));
+var BikeType;
+(function (BikeType) {
+    BikeType[BikeType["ALLROUND"] = 0] = "ALLROUND";
+    BikeType[BikeType["RACE"] = 1] = "RACE";
+    BikeType[BikeType["MOUNTAIN"] = 2] = "MOUNTAIN";
+})(BikeType = exports.BikeType || (exports.BikeType = {}));
+function getBikeType(bikeTypeStr) {
+    if (bikeTypeStr === undefined || bikeTypeStr === null)
+        return BikeType.RACE;
+    if (bikeTypeStr.toLowerCase() === 'mountain')
+        return BikeType.MOUNTAIN;
+    return BikeType.RACE;
+}
+exports.getBikeType = getBikeType;
+function routeToEpp(route, date) {
+    const buffer = Buffer.alloc(376 + route.points.length * 12);
+    const fileTime = win32filetime_1.default.fromUnix(date ? date : Date.now());
+    let offset = 0;
+    const name = route.name || '';
+    const description = route.description || '';
+    const minElevation = Math.min(...route.points.map(p => p.elevation));
+    const maxElevation = Math.max(...route.points.map(p => p.elevation));
+    const sampleRate = route.points.length !== 0 ? route.totalDistance / route.points.length : 0;
+    buffer.writeUInt32LE(fileTime.low, offset);
+    offset += 4;
+    buffer.writeUInt32LE(fileTime.high, offset);
+    offset += 4;
+    buffer.write(name, offset, name.length, 'ascii');
+    offset += 64;
+    buffer.write(description, offset, description.length, 'ascii');
+    offset += 256;
+    buffer.writeInt32LE(0x10, offset);
+    offset += 4;
+    buffer.writeInt32LE(0x0, offset);
+    offset += 4;
+    buffer.writeInt32LE(minElevation, offset);
+    offset += 4;
+    buffer.writeInt32LE(maxElevation, offset);
+    offset += 4;
+    buffer.writeInt32LE(route.points.length, offset);
+    offset += 4;
+    buffer.writeInt32LE(sampleRate, offset);
+    offset += 4;
+    buffer.writeInt32LE(0x01, offset);
+    offset += 4;
+    buffer.writeInt32LE(0x0, offset);
+    offset += 4;
+    buffer.writeInt16LE(0x0, offset);
+    offset += 2;
+    buffer.writeInt16LE(0x0, offset);
+    offset += 2;
+    buffer.writeInt32LE(0x0, offset);
+    offset += 4;
+    buffer.writeInt32LE(0x0, offset);
+    offset += 4;
+    buffer.writeInt32LE(0x0, offset);
+    offset += 4;
+    route.points.forEach(p => {
+        buffer.writeUInt32LE(sampleRate, offset);
+        offset += 4;
+        buffer.writeFloatLE(p.elevation, offset);
+        offset += 4;
+        buffer.writeFloatLE(0, offset);
+        offset += 4;
+    });
+    return new Uint8Array(buffer);
 }
-exports.getReservedCommandKey = getReservedCommandKey;
+exports.routeToEpp = routeToEpp;
 function parseTrainingData(payload) {
     const GS = 0x1D;
     const speedVals = ['ok', 'too low', 'too high'];
@@ -258,3 +329,47 @@ function parseTrainingData(payload) {
     return data;
 }
 exports.parseTrainingData = parseTrainingData;
+function getPersonData(user) {
+    const buffer = Buffer.alloc(136);
+    let offset = 0;
+    for (let i = 0; i < 4; i++) {
+        buffer.writeInt32LE(0, offset);
+        offset += 4;
+        buffer.writeFloatLE(-100, offset);
+        offset += 4;
+        buffer.writeFloatLE(0, offset);
+        offset += 4;
+        buffer.writeFloatLE(0, offset);
+        offset += 4;
+        buffer.writeUInt16LE(0, offset);
+        offset += 2;
+        buffer.writeUInt16LE(0, offset);
+        offset += 2;
+        buffer.writeUInt16LE(0, offset);
+        offset += 2;
+        buffer.writeUInt16LE(0, offset);
+        offset += 2;
+        buffer.writeUInt8(0, offset);
+        offset += 1;
+        buffer.writeUInt8(0, offset);
+        offset += 1;
+        buffer.writeUInt8(0, offset);
+        offset += 1;
+        buffer.writeUInt8(0, offset);
+        offset += 1;
+    }
+    buffer.writeInt32LE(user.sex === user_1.Gender.FEMALE ? 2 : 1, offset);
+    offset += 4;
+    buffer.writeInt32LE(user.age !== undefined ? user.age : utils_1.DEFAULT_AGE, offset);
+    offset += 4;
+    buffer.writeInt32LE(user.length !== undefined ? user.length : 180, offset);
+    offset += 4;
+    buffer.writeFloatLE(user.weight !== undefined ? user.weight : utils_1.DEFAULT_USER_WEIGHT, offset);
+    offset += 4;
+    buffer.writeFloatLE(0, offset);
+    offset += 4;
+    buffer.writeUInt32LE(0, offset);
+    offset += 4;
+    return buffer;
+}
+exports.getPersonData = getPersonData;

package/lib/types/route.d.ts

@@ -0,0 +1,21 @@
+export declare type Point = {
+    lat?: number;
+    lng?: number;
+    elevation?: number;
+    distance: number;
+    slope?: number;
+};
+export declare enum RouteType {
+    FREE_RIDE = "free ride",
+    FOLLOW_ROUTE = "follow route",
+    VIDEO = "video"
+}
+export declare type Route = {
+    programId: number;
+    points: Point[];
+    type: string;
+    name?: string;
+    description?: string;
+    lapMode: boolean;
+    totalDistance: number;
+};

package/lib/types/route.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteType = void 0;
+var RouteType;
+(function (RouteType) {
+    RouteType["FREE_RIDE"] = "free ride";
+    RouteType["FOLLOW_ROUTE"] = "follow route";
+    RouteType["VIDEO"] = "video";
+})(RouteType = exports.RouteType || (exports.RouteType = {}));

package/lib/types/user.d.ts

@@ -0,0 +1,11 @@
+export declare enum Gender {
+    MALE = "M",
+    FEMALE = "F",
+    OTHERS = "o"
+}
+export declare type User = {
+    weight?: number;
+    length?: number;
+    age?: number;
+    sex?: Gender;
+};

package/lib/types/user.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gender = void 0;
+var Gender;
+(function (Gender) {
+    Gender["MALE"] = "M";
+    Gender["FEMALE"] = "F";
+    Gender["OTHERS"] = "o";
+})(Gender = exports.Gender || (exports.Gender = {}));

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "incyclist-devices",
-  "version": "1.4.0",
+  "version": "1.4.3",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",
     "@types/serialport": "^8.0.1",
-    "gd-ant-plus": "^0.0.33"
+    "gd-ant-plus": "^0.0.33",
+    "win32filetime": "^1.0.2"
   },
   "peerDependencies": {
     "gd-eventlog": "^0.1.22"