ant-plus/build/speed-cadence-sensors.js

A node module for ANT+

"use strict";
/*
 * ANT+ profile: https://www.thisisant.com/developer/ant-plus/device-profiles/#523_tab
 * Spec sheet: https://www.thisisant.com/resources/bicycle-speed-and-cadence/
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.SpeedCadenceScanner = exports.SpeedCadenceSensor = void 0;
const ant_1 = require("./ant");
class SpeedCadenceSensorState {
    constructor(deviceID) {
        this.DeviceID = deviceID;
    }
}
class SpeedCadenceScanState extends SpeedCadenceSensorState {
}
class SpeedCadenceSensor extends ant_1.AntPlusSensor {
    constructor() {
        super(...arguments);
        this.wheelCircumference = 2.199; // default 70cm wheel
    }
    setWheelCircumference(wheelCircumference) {
        this.wheelCircumference = wheelCircumference;
    }
    attach(channel, deviceID) {
        super.attach(channel, 'receive', deviceID, SpeedCadenceSensor.deviceType, 0, 255, 8086);
        this.state = new SpeedCadenceSensorState(deviceID);
    }
    updateState(deviceId, data) {
        this.state.DeviceID = deviceId;
        updateState(this, this.state, data);
    }
}
exports.SpeedCadenceSensor = SpeedCadenceSensor;
SpeedCadenceSensor.deviceType = 0x79;
class SpeedCadenceScanner extends ant_1.AntPlusScanner {
    constructor() {
        super(...arguments);
        this.wheelCircumference = 2.199; // default 70cm wheel
        this.states = {};
    }
    deviceType() {
        return SpeedCadenceSensor.deviceType;
    }
    setWheelCircumference(wheelCircumference) {
        this.wheelCircumference = wheelCircumference;
    }
    createStateIfNew(deviceId) {
        if (!this.states[deviceId]) {
            this.states[deviceId] = new SpeedCadenceScanState(deviceId);
        }
    }
    updateRssiAndThreshold(deviceId, rssi, threshold) {
        this.states[deviceId].Rssi = rssi;
        this.states[deviceId].Threshold = threshold;
    }
    updateState(deviceId, data) {
        updateState(this, this.states[deviceId], data);
    }
}
exports.SpeedCadenceScanner = SpeedCadenceScanner;
function updateState(sensor, state, data) {
    //get old state for calculating cumulative values
    const oldCadenceTime = state.CadenceEventTime;
    const oldCadenceCount = state.CumulativeCadenceRevolutionCount;
    const oldSpeedTime = state.SpeedEventTime;
    const oldSpeedCount = state.CumulativeSpeedRevolutionCount;
    let cadenceTime = data.readUInt16LE(ant_1.Messages.BUFFER_INDEX_MSG_DATA);
    let cadenceCount = data.readUInt16LE(ant_1.Messages.BUFFER_INDEX_MSG_DATA + 2);
    let speedEventTime = data.readUInt16LE(ant_1.Messages.BUFFER_INDEX_MSG_DATA + 4);
    let speedRevolutionCount = data.readUInt16LE(ant_1.Messages.BUFFER_INDEX_MSG_DATA + 6);
    if (cadenceTime !== oldCadenceTime) {
        state.CadenceEventTime = cadenceTime;
        state.CumulativeCadenceRevolutionCount = cadenceCount;
        if (oldCadenceTime > cadenceTime) { //Hit rollover value
            cadenceTime += (1024 * 64);
        }
        if (oldCadenceCount > cadenceCount) { //Hit rollover value
            cadenceCount += (1024 * 64);
        }
        const cadence = ((60 * (cadenceCount - oldCadenceCount) * 1024) / (cadenceTime - oldCadenceTime));
        if (!isNaN(cadence)) {
            state.CalculatedCadence = cadence;
            sensor.emit('cadenceData', state);
        }
    }
    if (speedEventTime !== oldSpeedTime) {
        state.SpeedEventTime = speedEventTime;
        state.CumulativeSpeedRevolutionCount = speedRevolutionCount;
        if (oldSpeedTime > speedEventTime) { //Hit rollover value
            speedEventTime += (1024 * 64);
        }
        if (oldSpeedCount > speedRevolutionCount) { //Hit rollover value
            speedRevolutionCount += (1024 * 64);
        }
        const distance = sensor.wheelCircumference * (speedRevolutionCount - oldSpeedCount);
        state.CalculatedDistance = distance;
        //speed in m/sec
        const speed = (distance * 1024) / (speedEventTime - oldSpeedTime);
        if (!isNaN(speed)) {
            state.CalculatedSpeed = speed;
            sensor.emit('speedData', state);
        }
    }
}
//# sourceMappingURL=speed-cadence-sensors.js.map