incyclist-ant-plus/lib/sensors/speed-cadence-sensors.js

Incyclist library for ANT+ - originally forked from longhorn/ant-plus

"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 () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.SpeedCadenceSensorState = void 0;
const consts_1 = require("../consts");
const messages_1 = require("../messages");
const base_sensor_1 = __importStar(require("./base-sensor"));
class SpeedCadenceSensorState extends base_sensor_1.SensorState {
    constructor() {
        super(...arguments);
        this._CadenceUpdateTime = Date.now();
        this._SpeedUpdateTime = Date.now();
    }
}
exports.SpeedCadenceSensorState = SpeedCadenceSensorState;
const DEVICE_TYPE = 0x79;
const PROFILE = 'SC';
const PERIOD = 8086;
const DEFAULT_WHEEL_CIRCUMFERENCE = 2.118;
class SpeedCadenceSensor extends base_sensor_1.default {
    constructor() {
        super(...arguments);
        this.states = {};
        this.wheelCircumference = DEFAULT_WHEEL_CIRCUMFERENCE;
    }
    getDeviceType() {
        return DEVICE_TYPE;
    }
    getProfile() {
        return PROFILE;
    }
    getChannelConfiguration() {
        return { type: 'receive', transmissionType: 0, timeout: consts_1.Constants.TIMEOUT_NEVER, period: PERIOD, frequency: 57 };
    }
    onEvent(data) {
        return;
    }
    setWheelCircumference(wheelCircumference) {
        this.wheelCircumference = wheelCircumference;
    }
    onMessage(data) {
        const channel = this.getChannel();
        if (!channel)
            return;
        const channelNo = channel.getChannelNo();
        const deviceID = data.readUInt16LE(messages_1.Messages.BUFFER_INDEX_EXT_MSG_BEGIN + 1);
        const deviceType = data.readUInt8(messages_1.Messages.BUFFER_INDEX_EXT_MSG_BEGIN + 3);
        if (data.readUInt8(messages_1.Messages.BUFFER_INDEX_CHANNEL_NUM) !== channelNo || deviceType !== this.getDeviceType()) {
            return;
        }
        if (!this.states[deviceID]) {
            this.states[deviceID] = new SpeedCadenceSensorState(deviceID);
            this.states[deviceID].Channel = channelNo;
        }
        if (data.readUInt8(messages_1.Messages.BUFFER_INDEX_EXT_MSG_BEGIN) & 0x40) {
            if (data.readUInt8(messages_1.Messages.BUFFER_INDEX_EXT_MSG_BEGIN + 5) === 0x20) {
                this.states[deviceID].Rssi = data.readInt8(messages_1.Messages.BUFFER_INDEX_EXT_MSG_BEGIN + 6);
                this.states[deviceID].Threshold = data.readInt8(messages_1.Messages.BUFFER_INDEX_EXT_MSG_BEGIN + 7);
            }
        }
        switch (data.readUInt8(messages_1.Messages.BUFFER_INDEX_MSG_TYPE)) {
            case consts_1.Constants.MESSAGE_CHANNEL_BROADCAST_DATA:
            case consts_1.Constants.MESSAGE_CHANNEL_ACKNOWLEDGED_DATA:
            case consts_1.Constants.MESSAGE_CHANNEL_BURST_DATA:
                updateState(this, this.states[deviceID], data);
                if (this.deviceID === 0 || this.deviceID === deviceID) {
                    channel.onDeviceData(this.getProfile(), deviceID, this.states[deviceID]);
                }
                break;
            default:
                break;
        }
    }
}
exports.default = SpeedCadenceSensor;
function updateState(sensor, state, data) {
    state._RawData = data;
    const oldCadenceUpdateTime = state._CadenceUpdateTime;
    const oldSpeedUpdateTime = state._SpeedUpdateTime;
    const oldCadenceTime = state.CadenceEventTime;
    const oldCadenceCount = state.CumulativeCadenceRevolutionCount;
    const oldSpeedTime = state.SpeedEventTime;
    const oldSpeedCount = state.CumulativeSpeedRevolutionCount;
    const oldCalculatedCadence = state.CalculatedCadence;
    let cadenceDelay = 125000 / oldCalculatedCadence;
    let speedDelay = 3000;
    const updateTime = Date.now();
    let cadenceTime = data.readUInt16LE(messages_1.Messages.BUFFER_INDEX_MSG_DATA);
    const cadenceCount = data.readUInt16LE(messages_1.Messages.BUFFER_INDEX_MSG_DATA + 2);
    let speedTime = data.readUInt16LE(messages_1.Messages.BUFFER_INDEX_MSG_DATA + 4);
    const speedRevolutionCount = data.readUInt16LE(messages_1.Messages.BUFFER_INDEX_MSG_DATA + 6);
    if ((cadenceTime === oldCadenceTime) && (updateTime - oldCadenceUpdateTime >= cadenceDelay)) {
        state.CalculatedCadence = 0;
    }
    else if ((speedTime === oldSpeedTime) && (updateTime - oldSpeedUpdateTime >= speedDelay)) {
        state.CalculatedSpeed = 0;
    }
    else {
        state._CadenceUpdateTime = updateTime;
        state.CadenceEventTime = cadenceTime;
        state.CumulativeCadenceRevolutionCount = cadenceCount;
        if (oldCadenceTime > cadenceTime) {
            cadenceTime += 1024 * 64;
        }
        const cadence = (60 * (cadenceCount - oldCadenceCount) * 1024) / (cadenceTime - oldCadenceTime);
        if (!isNaN(cadence)) {
            state.CalculatedCadence = cadence;
        }
        state._SpeedUpdateTime = updateTime;
        state.SpeedEventTime = speedTime;
        state.CumulativeSpeedRevolutionCount = speedRevolutionCount;
        if (oldSpeedTime > speedTime) {
            speedTime += 1024 * 64;
        }
        const distance = sensor.wheelCircumference * (speedRevolutionCount - oldSpeedCount);
        state.CalculatedDistance = distance;
        const speed = (distance * 1024) / (speedTime - oldSpeedTime);
        if (!isNaN(speed)) {
            state.CalculatedSpeed = speed;
        }
    }
}