meoser/src/command.js

meos protocol engine

import {
    ascii2Str
} from './util';
import Transport from './transport';
import {genEvent} from './emitter';
import {
    REQUEST_TOPIC
} from './setting';

/**
 * 命令：用于发送协议
 */
class Command {

    constructor() {
        this.emiter = null;
    }

    init(emiter){
        this.emiter = emiter;
    }

    /**
     * 文件协议上传
     * @param  {Array} bytes 文件切片协议
     * @return {Promise}
     */
    upload(bytes) {
        let sendPromise = new Promise((resolve, reject) => {
            let timer;
            let handler_ = (data) => {
                clearTimeout(timer);
                resolve(data);
            };
            // 绑定一次性事件
            let fileEvent_ = genEvent(REQUEST_TOPIC.FLASH_FILE, this.emiter)(handler_, true);
            // 发送协议
            Transport.send(bytes);
            // 超时报错
            timer = setTimeout(() => {
                fileEvent_();
                reject({
                    'err': 'system error, please check the connection.'
                });
            }, 3000);
        })

        return sendPromise.then((resData) => {
            let err = null;
            // try 处理解析报错问题
            try {
                let statusCode = resData[9];
                // 0x00 表示 ok
                // 0x01 表示 error
                // 0xf0 文件校验失败
                if (resData[0] === 0xf3 && resData[resData.length - 1] === 0xf4) {
                    if (statusCode === 0x01) {
                        err = `file upload error, status code: ${statusCode}, please check the firmware.`;
                    } else if (statusCode === 0xf0) {
                        err = `file check error, status code: ${statusCode}, please make sure encode file rightly.`;
                    } else if (statusCode !== 0x00) {
                        err = `unkown status error, status code: ${statusCode}, please check the firmware.`;
                    }
                } else {
                    console.warn(`status code parsed error with buffer: ${ascii2Str(resData)}`);
                }
            } catch (e) {
                err = 'parse data error, please check the response data.'; //下位机响应数据
            }
            return Promise.resolve({
                err
            });
        }).catch((err) => {
            return Promise.resolve({
                err
            });
        })
    }

    /**
     * 请求响应模型，用于读值请求、查询、握手
     * @param  {Array} bytes 请求协议
     * @example
     * [243,251,8,0,   4, 2,  44,1,  0,0,0,0,   51,244]
     * @return {Promise}
     */
    request(requestType, bytes, options) {
        let msg_ = 'please check the connection or the firmware version.';
        let watchTimer = options.time || 5000;
        let desc = options.desc;
        return new Promise((resolve, reject) => {
            let timer;
            /**
             *
             * @param {Oject} result 结果对象
             * @param {Oject.String} result.msg 成功、失败的结果描述
             * @param {Boolean} isSuccess
             */
            let handler_ = (result, isSuccess=true) => { // {sensor_id, action}
                clearTimeout(timer);
                // console.log('成功', requestType.toString())
                if(isSuccess) { // 成功
                    resolve(result);
                }else { // 失败
                    let err = result.msg ? `${desc} ${result.msg}`: `${desc} request error, ${msg_}`;
                    result.err = err;
                    resolve(result);
                }
            };
            // 绑定一次性事件
            let requestEvent_ = genEvent(requestType, this.emiter)(handler_, true);
            // 发送协议
            Transport.send(bytes);
            // 超时报错
            timer = setTimeout(() => {
                // console.log('失败', requestType.toString())
                requestEvent_();
                resolve({
                    'err': `timeout error, ${msg_}`
                });
            }, watchTimer);
        })
    }
}

export default new Command();