incyclist-devices 2.0.34 → 2.0.36

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

@@ -0,0 +1,6 @@
+export declare const DEFAULT_TIMEOUT = 10000;
+export declare const DEFAULT_ACK_TIMEOUT = 11000;
+export declare const DEFAULT_BUSY_TIMEOUT = 5000;
+export declare const MAX_DATA_BLOCK_SIZE = 512;
+export declare const DS_BITS_OFF = 0;
+export declare const DS_BITS_ENDLESS_RACE = 2;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DS_BITS_ENDLESS_RACE = exports.DS_BITS_OFF = exports.MAX_DATA_BLOCK_SIZE = exports.DEFAULT_BUSY_TIMEOUT = exports.DEFAULT_ACK_TIMEOUT = exports.DEFAULT_TIMEOUT = void 0;
+exports.DEFAULT_TIMEOUT = 10000;
+exports.DEFAULT_ACK_TIMEOUT = 11000;
+exports.DEFAULT_BUSY_TIMEOUT = 5000;
+exports.MAX_DATA_BLOCK_SIZE = 512;
+exports.DS_BITS_OFF = 0;
+exports.DS_BITS_ENDLESS_RACE = 2;

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

@@ -28,6 +28,26 @@ export declare class Daum8iMockImpl {
     list(): Promise<import("@serialport/bindings-interface").PortInfo[]>;
     open(options: any): Promise<Daum8iMockBinding>;
 }
+type Program = {
+    lapMode: boolean;
+    id?: number;
+    started?: boolean;
+};
+type trainingData = {
+    time: number;
+    heartrate: number;
+    v: number;
+    slope: number;
+    distanceInternal: number;
+    pedalRpm: number;
+    power: number;
+    physEnergy: number;
+    realEnergy: number;
+    torque: number;
+    gear: number;
+    deviceState: number;
+    speedStatus: number;
+};
 export declare class Daum8MockSimulator {
     protoVersion: string;
     dashboardVersion: string;
@@ -38,16 +58,21 @@ export declare class Daum8MockSimulator {
     currentPower: number;
     loadControl: number;
     person: User;
+    program: Program;
+    data: trainingData;
     _isSimulateACKTimeout: boolean;
     _isSimulateCheckSumError: boolean;
+    _isSimulateReservedError: boolean;
     _timeoutResponse: number;
     timeoutNAKRetry: number;
     simulateACKTimeout(): void;
     simulateTimeout(ms: number): void;
     simulateChecksumError(): void;
+    simulateReservedError(): void;
     onNAK(): void;
     onACK(): void;
 }
+export declare function parseProgramListNewData(buffer: Buffer): Program;
 export declare class Daum8iMockBinding extends MockPortBinding {
     waitingForCommand: boolean;
     waitingForAck: boolean;
@@ -59,7 +84,7 @@ export declare class Daum8iMockBinding extends MockPortBinding {
     initHandlers(): void;
     write(buffer: Buffer): Promise<void>;
     processData(buffer: Buffer): Promise<void>;
-    createResponse(cmd: string, payload: Buffer): Buffer;
+    createResponse(cmd: string, payload: Buffer, binary?: boolean): Buffer;
     emitData(data: string | Buffer): void;
     onGetProtcolVersion(_payload: Buffer): void;
     onGetDashboardVersion(_payload: Buffer): void;
@@ -71,5 +96,11 @@ export declare class Daum8iMockBinding extends MockPortBinding {
     onReservedCommand(payload: Buffer): void;
     onPersonSet(payload: Buffer): void;
     onPersonGet(): void;
+    onProgramListBegin(): void;
+    onProgramListNewProgram(payload: Buffer): void;
+    onProgramListEnd(): void;
+    onProgramListContinueProgram(): void;
+    onProgramListStart(payload: Buffer): void;
     onGetTrainingData(_payload: Buffer): void;
 }
+export {};

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

@@ -9,12 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Daum8iMockBinding = exports.Daum8MockSimulator = exports.Daum8iMockImpl = exports.Daum8iMock = void 0;
+exports.Daum8iMockBinding = exports.parseProgramListNewData = 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");
+const consts_1 = require("./consts");
 exports.Daum8iMock = {
     reset() {
         Daum8iMockImpl.getInstance().reset();
@@ -73,6 +74,21 @@ class Daum8iMockImpl {
     }
 }
 exports.Daum8iMockImpl = Daum8iMockImpl;
+const DEFAULT_TRAINING_DATA = {
+    time: 0,
+    heartrate: 0,
+    v: 0,
+    slope: 0,
+    distanceInternal: 0,
+    pedalRpm: 0,
+    power: 0,
+    physEnergy: 0,
+    realEnergy: 0,
+    torque: 0,
+    gear: 10,
+    deviceState: 1,
+    speedStatus: 0
+};
 class Daum8MockSimulator {
     constructor() {
         this.protoVersion = '201';
@@ -84,8 +100,10 @@ class Daum8MockSimulator {
         this.currentPower = 0;
         this.loadControl = 1;
         this.person = { weight: 75, length: 180, age: 30, sex: user_1.Gender.MALE };
+        this.data = DEFAULT_TRAINING_DATA;
         this._isSimulateACKTimeout = false;
         this._isSimulateCheckSumError = false;
+        this._isSimulateReservedError = false;
         this._timeoutResponse = 0;
         this.timeoutNAKRetry = 1000;
     }
@@ -98,10 +116,19 @@ class Daum8MockSimulator {
     simulateChecksumError() {
         this._isSimulateCheckSumError = true;
     }
+    simulateReservedError() {
+        this._isSimulateReservedError = true;
+    }
     onNAK() { }
     onACK() { }
 }
 exports.Daum8MockSimulator = Daum8MockSimulator;
+function parseProgramListNewData(buffer) {
+    const wBits = buffer.readInt16LE(30);
+    const lapMode = wBits === consts_1.DS_BITS_ENDLESS_RACE;
+    return { lapMode };
+}
+exports.parseProgramListNewData = parseProgramListNewData;
 class Daum8iMockBinding extends binding_mock_1.MockPortBinding {
     constructor(parent) {
         super(parent.port, parent.openOptions);
@@ -214,8 +241,14 @@ class Daum8iMockBinding extends binding_mock_1.MockPortBinding {
             }
         });
     }
-    createResponse(cmd, payload) {
-        const buffer = Buffer.from((0, utils_2.buildMessage)(cmd, payload));
+    createResponse(cmd, payload, binary = false) {
+        let buffer;
+        if (binary) {
+            buffer = Buffer.from((0, utils_2.buildMessage)(cmd, (0, utils_2.bin2esc)(payload)));
+        }
+        else {
+            buffer = Buffer.from((0, utils_2.buildMessage)(cmd, payload));
+        }
         this.prevCommand = Buffer.from(buffer);
         if (this.simulator._isSimulateCheckSumError) {
             this.simulator._isSimulateCheckSumError = false;
@@ -267,20 +300,110 @@ class Daum8iMockBinding extends binding_mock_1.MockPortBinding {
     }
     onReservedCommand(payload) {
         const cmd = payload.readInt16LE(0);
-        const length = payload.readUint16LE(2);
-        const data = (0, utils_2.esc2bin)(payload.subarray(4, 4 + length - 1));
+        const data = (0, utils_2.esc2bin)(payload.subarray(4, 4 + payload.length - 1));
         switch (cmd) {
-            case utils_2.ReservedCommands.PERSON_SET: this.onPersonSet(Buffer.from(data));
-            case utils_2.ReservedCommands.PERSON_GET: this.onPersonGet();
+            case utils_2.ReservedCommands.PERSON_SET:
+                this.onPersonSet(Buffer.from(data));
+                break;
+            case utils_2.ReservedCommands.PERSON_GET:
+                this.onPersonGet();
+                break;
+            case utils_2.ReservedCommands.PROGRAM_LIST_BEGIN:
+                this.onProgramListBegin();
+                break;
+            case utils_2.ReservedCommands.PROGRAM_LIST_NEW_PROGRAM:
+                this.onProgramListNewProgram(Buffer.from(data));
+                break;
+            case utils_2.ReservedCommands.PROGRAM_LIST_CONTINUE_PROGRAM:
+                this.onProgramListContinueProgram();
+                break;
+            case utils_2.ReservedCommands.PROGRAM_LIST_END:
+                this.onProgramListEnd();
+                break;
+            case utils_2.ReservedCommands.PROGRAM_LIST_START:
+                this.onProgramListStart(Buffer.from(data));
+                break;
         }
     }
     onPersonSet(payload) {
         this.simulator.person = (0, utils_2.parsePersonData)(payload);
-        this.emitData(this.createResponse('M70', Buffer.from('07000000', 'hex')));
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex')));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else
+            this.emitData(this.createResponse('M70', Buffer.from('07000000', 'hex'), true));
     }
     onPersonGet() {
     }
+    onProgramListBegin() {
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('07000000', 'hex'), true));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex'), true));
+    }
+    onProgramListNewProgram(payload) {
+        this.simulator.program = parseProgramListNewData(payload);
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex'), true));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else
+            this.emitData(this.createResponse('M70', Buffer.from('09000000', 'hex'), true));
+    }
+    onProgramListEnd() {
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex'), true));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else
+            this.emitData(this.createResponse('M70', Buffer.from('0B00010001', 'hex'), true));
+    }
+    onProgramListContinueProgram() {
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex'), true));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else
+            this.emitData(this.createResponse('M70', Buffer.from('0A00010001', 'hex'), true));
+    }
+    onProgramListStart(payload) {
+        if (this.simulator._isSimulateReservedError) {
+            this.emitData(this.createResponse('M70', Buffer.from('08000000', 'hex'), true));
+            this.simulator._isSimulateReservedError = false;
+        }
+        else {
+            try {
+                if (!this.simulator.program)
+                    this.simulator.program = { lapMode: false };
+                this.simulator.program.id = payload.readInt16LE(0);
+                this.simulator.program.started = true;
+            }
+            catch (err) {
+                console.log('~~~ ERROR', payload, err, payload.toString('hex'));
+            }
+            this.emitData(this.createResponse('M70', Buffer.from('0C00000', 'hex'), true));
+        }
+    }
     onGetTrainingData(_payload) {
+        const GS = Buffer.from([0x1D]).toString();
+        const { time, heartrate, v, slope, distanceInternal, pedalRpm, power, physEnergy, realEnergy, torque, gear, deviceState, speedStatus } = this.simulator.data;
+        const res = `${time}` + GS +
+            `${heartrate}` + GS +
+            `${v}` + GS +
+            `${slope}` + GS +
+            `${distanceInternal}` + GS +
+            `${pedalRpm}` + GS +
+            `${power}` + GS +
+            `${physEnergy}` + GS +
+            `${realEnergy}` + GS +
+            `${torque}` + GS +
+            `${gear}` + GS +
+            `${deviceState}` + GS +
+            `${speedStatus}`;
+        this.emitData(this.createResponse('X70', Buffer.from(res)));
     }
 }
 exports.Daum8iMockBinding = Daum8iMockBinding;

package/lib/serial/daum/premium/modes/daum-classic.d.ts

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

package/lib/serial/daum/premium/modes/daum-classic.js

@@ -16,7 +16,7 @@ const config = {
 class DaumClassicCyclingMode extends DaumPowerMeterCyclingMode_1.default {
     constructor(adapter, props) {
         super(adapter, props);
-        this.logger = adapter ? adapter.logger : undefined;
+        this.logger = adapter ? adapter.getLogger() : undefined;
         if (!this.logger)
             this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
         this.setModeProperty('eppSupport', true);

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

@@ -1,5 +1,21 @@
-import { DeviceProperties } from "../../../types/device";
+import { DaumBikeData, DeviceProperties } from "../../../types/device";
 import { Route } from "../../../types/route";
+import { Queue } from "../../../utils/utils";
+import { Request, Response } from "../../comms";
+export declare class CheckSumError extends Error {
+    constructor();
+}
+export declare class ACKTimeout extends Error {
+    constructor();
+}
+export declare class BusyTimeout extends Error {
+    constructor();
+}
+export declare class ResponseTimeout extends Error {
+    constructor();
+}
+export interface DaumPremiumBikeData extends DaumBikeData {
+}
 export type OnDeviceStartCallback = (completed: number, total: number) => void;
 export type DaumPremiumAdapterProps = {
     path: string;
@@ -10,3 +26,21 @@ export interface Daum8iDeviceProperties extends DeviceProperties {
     gear?: number;
     onStatusUpdate?: OnDeviceStartCallback;
 }
+export interface DaumPremiumRequest extends Request {
+    command: string;
+    payload?: string | Uint8Array;
+}
+export interface ResponseObject extends Response {
+    type: ResponseType;
+    cmd?: string;
+    data?: string;
+    error?: Error;
+}
+export type ResponseType = 'ACK' | 'NAK' | 'Response' | 'Error';
+export type DaumPremiumCommsState = {
+    waitingForStart?: boolean;
+    waitingForACK?: boolean;
+    waitingForEnd?: boolean;
+    partialCmd?: any;
+    data: Queue<ResponseObject>;
+};

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

@@ -1,2 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseTimeout = exports.BusyTimeout = exports.ACKTimeout = exports.CheckSumError = void 0;
+class CheckSumError extends Error {
+    constructor() {
+        super();
+        this.message = 'checksum incorrect';
+    }
+}
+exports.CheckSumError = CheckSumError;
+class ACKTimeout extends Error {
+    constructor() {
+        super();
+        this.message = 'ACK timeout';
+    }
+}
+exports.ACKTimeout = ACKTimeout;
+class BusyTimeout extends Error {
+    constructor() {
+        super();
+        this.message = 'BUSY timeout';
+    }
+}
+exports.BusyTimeout = BusyTimeout;
+class ResponseTimeout extends Error {
+    constructor() {
+        super();
+        this.message = 'RESP timeout';
+    }
+}
+exports.ResponseTimeout = ResponseTimeout;

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

@@ -1,13 +1,20 @@
 /// <reference types="node" />
+import { IncyclistBikeData } from "../../..";
 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 const DEBUG_LOGGER: {
+    log: (e: any, ...args: any[]) => void;
+    logEvent: (event: any) => void;
+};
+export declare const validateHost: (host: string) => string;
+export declare const validatePath: (path: string) => string;
+export declare function bin2esc(arr: Uint8Array): Uint8Array;
+export declare function esc2bin(arr: Uint8Array): Uint8Array;
 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 ascii(c: any): any;
+export declare function ascii(c: string): number;
 export declare function getAsciiArrayFromStr(str: any): any[];
 export declare enum ReservedCommands {
     RESULT_RESET = 0,
@@ -40,20 +47,6 @@ export declare const FileTimeSupport: {
     fromDate: (date: Date) => any;
 };
 export declare function routeToEpp(route: Route, date?: Date): Uint8Array;
-export declare function parseTrainingData(payload: string): {
-    time: number;
-    heartrate: number;
-    speed: number;
-    slope: number;
-    distanceInternal: number;
-    cadence: number;
-    power: number;
-    physEnergy: number;
-    realEnergy: number;
-    torque: number;
-    gear: number;
-    deviceState: number;
-    speedStatus: string;
-};
+export declare function parseTrainingData(payload: string): IncyclistBikeData;
 export declare function getPersonData(user: User): Buffer;
 export declare function parsePersonData(buffer: Buffer): User;

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

@@ -3,14 +3,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+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 = exports.validatePath = exports.validateHost = exports.DEBUG_LOGGER = void 0;
 const user_1 = require("../../../types/user");
 const win32filetime_1 = __importDefault(require("win32filetime"));
 const sum = (arr) => arr.reduce((a, b) => a + b, 0);
+exports.DEBUG_LOGGER = {
+    log: (e, ...args) => console.log(e, ...args),
+    logEvent: (event) => console.log(JSON.stringify(event))
+};
+const validateHost = (host) => {
+    const ipParts = host.split('.');
+    if (ipParts.length > 1)
+        return ipParts.map(p => Number(p)).join('.');
+    return host;
+};
+exports.validateHost = validateHost;
+const validatePath = (path) => {
+    const parts = path.split(':');
+    if (parts.length < 2)
+        return path;
+    const host = (0, exports.validateHost)(parts[0]);
+    const port = parts[1];
+    return `${host}:${port}`;
+};
+exports.validatePath = validatePath;
 function bin2esc(arr) {
-    if (arr === undefined) {
-        return;
-    }
     const res = [];
     arr.forEach(v => {
         switch (v) {
@@ -42,13 +59,10 @@ function bin2esc(arr) {
                 res.push(v);
         }
     });
-    return res;
+    return new Uint8Array(res);
 }
 exports.bin2esc = bin2esc;
 function esc2bin(arr) {
-    if (arr === undefined) {
-        return;
-    }
     const res = [];
     let escaped = false;
     arr.forEach((v, idx) => {
@@ -84,7 +98,7 @@ function esc2bin(arr) {
             res.push(v);
         }
     });
-    return res;
+    return new Uint8Array(res);
 }
 exports.esc2bin = esc2bin;
 function checkSum(cmdArr, payload) {
@@ -147,8 +161,6 @@ function hexstr(arr, start, len) {
 }
 exports.hexstr = hexstr;
 function ascii(c) {
-    if (c === undefined || c === null)
-        return;
     return c.charCodeAt(0);
 }
 exports.ascii = ascii;
@@ -258,7 +270,6 @@ function routeToEpp(route, date) {
 exports.routeToEpp = routeToEpp;
 function parseTrainingData(payload) {
     const GS = 0x1D;
-    const speedVals = ['ok', 'too low', 'too high'];
     const gearVal = (v) => v > 0 ? v - 1 : undefined;
     const vals = payload.split(String.fromCharCode(GS));
     const data = {
@@ -267,15 +278,11 @@ function parseTrainingData(payload) {
         speed: parseFloat(vals[2]) * 3.6,
         slope: parseFloat(vals[3]),
         distanceInternal: parseInt(vals[4]),
-        cadence: parseFloat(vals[5]),
+        pedalRpm: parseFloat(vals[5]),
         power: parseInt(vals[6]),
-        physEnergy: parseFloat(vals[7]),
-        realEnergy: parseFloat(vals[8]),
-        torque: parseFloat(vals[9]),
         gear: gearVal(parseInt(vals[10])),
-        deviceState: parseInt(vals[11]),
-        speedStatus: speedVals[parseInt(vals[12])],
     };
+    data.isPedalling = (data.pedalRpm > 0);
     return data;
 }
 exports.parseTrainingData = parseTrainingData;

package/lib/serial/serial-interface.js

@@ -58,7 +58,7 @@ class SinglePathScanner {
                 return;
             this.isScanning = true;
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                this.logEvent({ message: 'starting scan', path: this.path });
+                this.logEvent({ message: 'starting scan', path: this.path, interface: this.serial.getName() });
                 this.serial.scanEvents.on('timeout', () => this.onStopRequest(resolve));
                 this.serial.scanEvents.on('stop', () => this.onStopRequest(resolve));
                 let found = false;
@@ -78,6 +78,7 @@ class SinglePathScanner {
                         if (found) {
                             this.isFound = true;
                             const name = adapter.getName();
+                            yield adapter.close();
                             resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
                         }
                         yield (0, utils_1.sleep)(100);
@@ -166,9 +167,11 @@ class SerialInterface extends events_1.default {
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'connecting', interface: this.ifaceName });
             const binding = serialport_1.default.getInstance().getBinding(this.ifaceName);
             if (!binding || !this.binding) {
                 this.connected = false;
+                this.logEvent({ message: 'connecting error', interface: this.ifaceName, reason: 'no binfing found' });
                 return false;
             }
             try {
@@ -178,6 +181,7 @@ class SerialInterface extends events_1.default {
                 return true;
             }
             catch (err) {
+                this.logEvent({ message: 'connecting error', interface: this.ifaceName, reason: err.message });
                 this.connected = false;
                 return false;
             }
@@ -210,7 +214,7 @@ class SerialInterface extends events_1.default {
             }
             return new Promise((resolve) => {
                 port.once('error', (err) => {
-                    this.logEvent({ message: 'error', path, error: err.message || err });
+                    this.logEvent({ message: 'error', path, error: err.message || err, stack: err.stack });
                     port.removeAllListeners();
                     resolve(null);
                 });
@@ -273,14 +277,15 @@ class SerialInterface extends events_1.default {
             }
             this.isScanning = true;
             let attemptNo = 0;
+            const isTcpip = this.getName() === 'tcpip';
             do {
                 if (attemptNo === 0)
-                    this.logEvent({ message: 'checking for ports', port, excludes: this.inUse });
+                    this.logEvent({ message: 'checking for ports', interface: this.ifaceName, port, excludes: this.inUse });
                 else
-                    this.logEvent({ message: 'checking for ports retry', retry: attemptNo });
+                    this.logEvent({ message: 'checking for ports retry', interface: this.ifaceName, retry: attemptNo });
                 attemptNo++;
                 try {
-                    if (this.getName() === 'tcpip') {
+                    if (isTcpip) {
                         const _binding = binding;
                         paths = (yield _binding.list(port, this.inUse)) || [];
                     }
@@ -289,8 +294,9 @@ class SerialInterface extends events_1.default {
                     }
                 }
                 catch (err) {
-                    console.log('~~~ERROR', err);
+                    this.logEvent({ message: 'error', fn: 'scan#detect ports', error: err.message, interface: this.ifaceName, port, excludes: this.inUse });
                 }
+                paths = paths.filter(p => !this.inUse.includes(p.path));
                 if (!paths || paths.length === 0) {
                     this.logEvent({ message: 'scanning: no ports detected', interface: this.ifaceName, paths: paths.map(p => p.path), timeout });
                     yield (0, utils_1.sleep)(1000);
@@ -298,7 +304,6 @@ class SerialInterface extends events_1.default {
                 if (Date.now() > toExpiresAt)
                     timeOutExpired = true;
             } while (this.isScanning && !timeOutExpired && paths.length === 0);
-            paths = paths.filter(p => !this.inUse.includes(p.path));
             if (paths.length === 0) {
                 this.logEvent({ message: 'nothing to scan ' });
                 if (this.toScan) {
@@ -307,19 +312,20 @@ class SerialInterface extends events_1.default {
                 }
                 return [];
             }
-            this.logEvent({ message: 'scanning on ', paths: paths.map(p => p.path), timeout });
+            this.logEvent({ message: 'scanning on ', interface: this.ifaceName, paths: paths.map(p => p.path).join(','), timeout });
             const scanners = paths.map(p => new SinglePathScanner(p.path, this, Object.assign(Object.assign({}, props), { logger: this.logger })));
             try {
                 yield Promise.all(scanners.map(s => s.scan()
-                    .then(device => {
+                    .then((device) => __awaiter(this, void 0, void 0, function* () {
                     if (device) {
                         const adapter = adapter_factory_1.default.getInstance().createInstance(device);
                         const path = adapter.getPort();
                         this.inUse.push(path);
+                        yield adapter.stop();
                         detected.push(device);
                         this.emit('device', device);
                     }
-                })
+                }))
                     .catch()));
             }
             catch (err) {
@@ -346,6 +352,7 @@ class SerialInterface extends events_1.default {
                 clearTimeout(this.toScan);
                 this.toScan = null;
             }
+            this.isScanning = false;
             this.scanEvents.emit('stop');
             return true;
         });

package/lib/types/adapter.d.ts

@@ -5,8 +5,10 @@ import { IncyclistCapability } from "./capabilities";
 import { DeviceData } from "./data";
 import { DeviceProperties, DeviceSettings } from "./device";
 import { User } from "./user";
+import { EventLogger } from "gd-eventlog";
 export type OnDeviceDataCallback = (data: DeviceData) => void;
 export interface IncyclistDeviceAdapter extends EventEmitter {
+    getLogger(): EventLogger;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
     check(): Promise<boolean>;

package/lib/types/device.d.ts

@@ -9,11 +9,22 @@ export declare const INTERFACE: {
     USB: string;
     SIMULATOR: string;
 };
+export type DeviceType = 'race' | 'mountain' | 'triathlon';
 export type Device = {
     getID(): string;
     getName(): string;
     getInterface(): string;
 };
+export type DaumBikeData = {
+    cadence: number;
+    speed: number;
+    power: number;
+    heartrate: number;
+    distanceInternal: number;
+    gear: number;
+    time: number;
+    slope?: number;
+};
 export type DeviceProperties = {
     user?: User;
     userWeight?: number;