weblab-instrument
Version:
communication with instrument through usb
1,209 lines (1,089 loc) • 41.8 kB
JavaScript
/* eslint no-restricted-syntax: 0 */
/* eslint no-await-in-loop: 0 */
/**
* Module use to communicate with GWINSTEK's DSO through Ethernet or USB
*
* @module instrument-com
*/
import cmdObj from './sys/lcr-command.json';
const EventEmitter = require('events').EventEmitter;
const debug = require('debug');
const log = debug('lcr:log');
const syscmd = require('./lcr/system.js');
const fetch = require('./lcr/measure.js');
const usbDev = require('./dev/devUsb.js');
const base = require('./dev/base.js');
const DELAY_CNT = 150;
/**
* Create all needed private properties and method
*
* @private
* @constructor LcdObject
*
* @return {Object} Private method used to control DSO
*/
const LcdObject = function LcdObject() {
this.dev = new base.Dev();
this.sys = syscmd.initLcrSysObj.call(this, 'sys');
this.meas = fetch.initLcrMeasObj.call(this, 'meas');
this.cmdEvent = new EventEmitter();
this.commandObj = cmdObj;
this.dev.commandObj = this.commandObj;
return this;
};
/**
* The class define all needed public properties and methods
*
* @class lcrctrl
*
*
*/
function LcrControl(lcrObj) {
const lcrctrl = {};
/**
* The method belong to lcrctrl class used to release device's resource.
*
* @method closeDev
* @return {null} null
*
*/
lcrctrl.closeDev = function closeDev() {
log('closeDev');
return new Promise(((resolve, reject) => {
lcrctrl.disconnect()
.then(resolve)
.catch((e) => {
reject(e);
});
}));
};
// let all_the_types = mdns.browseThemAll();
/**
* The method belong to lcrctrl class used to connect to device,
* connect method must be called and wait to complete before any lcrctrl method.
*
* @method connect
*
*
*/
lcrctrl.connect = function connect(dontCheckdev) {
const self = this;
return new Promise(((resolve, reject) => {
function conn(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
self.dev.usbConnect(conn, dontCheckdev);
/*
if (self.dev.interf === 'usb') {
self.dev.usbConnect(conn);
}else if (self.dev.interf === 'net') {
self.dev.tcpConnect(conn);
}
else{
reject(Error('Not supported interface'));
}
*/
}));
}.bind(lcrObj);
/**
* The method belong to lcrctrl class used to disconnect from device.
*
* @method disconnect
*
*
*/
lcrctrl.disconnect = function disconnect() {
log('disconnect');
const self = this;
return new Promise(((resolve, reject) => {
function disconnectDone(e) {
if (e) {
log('disconnect return');
log(e);
reject(e);
} else {
resolve();
}
}
self.dev.asyncWrite = 'done';
self.dev.queryBlock = false;
self.dev.state.setTimeout = false;
if (self.dev.state.conn !== 'disconnected') {
self.dev.cmdSequence = [];
if (self.dev.writeTimeoutObj !== null) {
clearTimeout(self.dev.writeTimeoutObj);
}
self.dev.usbDisconnect(disconnectDone);
/*
if (self.dev.interf === 'usb') {
self.dev.usbDisconnect(disconnectDone);
}else if (self.dev.interf === 'net') {
self.dev.tcpDisconnect(disconnectDone);
}else{
resolve();
}
*/
} else {
resolve();
}
}));
}.bind(lcrObj);
lcrctrl.setDelay = function setDelay(val) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve(self.sys.status);
}
}
const sysCmd = [
{ id: 'sys', prop: 'delay_for_a_while', arg: parseInt(val, 10), cb: setDone, method: 'set' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getSetup = function getSetup() {
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(Object.assign({}, self.sys, self.meas));
}
}
const cmd = [];
log('lcr getSetup');
cmd.push({ id: 'sys', prop: 'ApertureAVG', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'ApertureRate', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'LevelMode', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'LevelALC', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'LevelSresistance', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'Frequency', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'Bias', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'DispPage', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'TriggerSource', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'TriggerDelay', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuncImpeAuto', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuncImpeRange', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuncDcrRange', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuncRangeAuto', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuntMonitor1', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuntMonitor2', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'Function', arg: '', cb: getDone, method: 'get' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
self.dev.cmdSequence = self.dev.cmdSequence.concat(cmd);
// log(self.dev.cmdSequence);
self.cmdEvent.emit('cmdWrite', cmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setSetup = function setSetup(setup) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
log('lcr.setSetup error');
log(e);
reject(e);
} else {
resolve();
}
}
const cmd = [];
log('lcr setSetup');
log(setup);
cmd.push({ id: 'sys', prop: 'SetApertureAVG', arg: setup.aperture.avg, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'SetApertureRate', arg: setup.aperture.rate, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'LevelALC', arg: setup.level.alc.toUpperCase(), cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'LevelSresistance', arg: setup.level.resist, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'Frequency', arg: setup.freq, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'Bias', arg: setup.bias, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'DispPage', arg: setup.disppage.toUpperCase(), cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'TriggerSource', arg: setup.source, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'TriggerDelay', arg: setup.delay.slice(0, -1), cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuncImpeAuto', arg: setup.FuncImpeAuto.toUpperCase(), cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuncImpeRange', arg: setup.FuncImpeRange, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuncDcrRange', arg: setup.FuncDcrRange, cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuncRangeAuto', arg: setup.FuncRangeAuto.toUpperCase(), cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuntMonitor1', arg: setup.FuntMonitor1.toUpperCase(), cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'FuntMonitor2', arg: setup.FuntMonitor2.toUpperCase(), cb: null, method: 'set' });
cmd.push({ id: 'sys', prop: 'delay_for_a_while', arg: DELAY_CNT, cb: null, method: 'set' });
cmd.push({ id: 'meas', prop: 'Function', arg: setup.func, cb: setDone, method: 'set' });
self.dev.cmdSequence = self.dev.cmdSequence.concat(cmd);
// log(self.dev.cmdSequence);
self.cmdEvent.emit('cmdWrite', cmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getBias = function getBias() {
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(self.sys.bias);
}
}
const sysCmd = [
{ id: 'sys', prop: 'Bias', arg: '', cb: getDone, method: 'get' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setBias = function setBias(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [];
// const biasPara = ['OFF', 'MIN', 'MAX'];
if (arg.toUpperCase() === 'OFF') {
sysCmd.push({ id: 'sys', prop: 'Bias', arg, cb: setDone, method: 'set' });
} else {
sysCmd.push({ id: 'sys', prop: 'BiasVAL', arg, cb: setDone, method: 'set' });
}
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setTriggerSource = function setTriggerSource(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [];
sysCmd.push({ id: 'sys', prop: 'TriggerSource', arg, cb: setDone, method: 'set' });
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getDispPage = function getDispPage() {
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(self.sys.disppage);
}
}
const sysCmd = [
{ id: 'sys', prop: 'DispPage', arg: '', cb: getDone, method: 'get' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setDispPage = function setDispPage(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [
{ id: 'sys', prop: 'DispPage', arg, cb: setDone, method: 'set' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getFunction = function getFunction() {
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(self.meas.func);
}
}
const sysCmd = [
{ id: 'meas', prop: 'Function', arg: '', cb: getDone, method: 'get' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setFunction = function setFunction(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [
{ id: 'meas', prop: 'Function', arg, cb: setDone, method: 'set' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getFuncImpeAuto = function getFuncImpeAuto() {
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(self.meas.FuncImpeAuto);
}
}
const sysCmd = [
{ id: 'meas', prop: 'FuncImpeAuto', arg: '', cb: getDone, method: 'get' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setFuncImpeAuto = function setFuncImpeAuto(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [
{ id: 'meas', prop: 'FuncImpeAuto', arg, cb: setDone, method: 'set' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getFuncImpeRange = function getFuncImpeRange() {
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(self.meas.FuncImpeRange);
}
}
const sysCmd = [
{ id: 'meas', prop: 'FuncImpeRange', arg: '', cb: getDone, method: 'get' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setFuncImpeRange = function setFuncImpeRange(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [
{ id: 'meas', prop: 'FuncImpeRange', arg, cb: setDone, method: 'set' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getFuncDcrRange = function getFuncDcrRange() {
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(self.meas.FuncDcrRange);
}
}
const sysCmd = [
{ id: 'meas', prop: 'FuncDcrRange', arg: '', cb: getDone, method: 'get' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setFuncDcrRange = function setFuncDcrRange(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [
{ id: 'meas', prop: 'FuncDcrRange', arg, cb: setDone, method: 'set' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getFuncRangeAuto = function getFuncRangeAuto() {
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(self.meas.FuncRangeAuto);
}
}
const sysCmd = [
{ id: 'meas', prop: 'FuncRangeAuto', arg: '', cb: getDone, method: 'get' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setFuncRangeAuto = function setFuncRangeAuto(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [
{ id: 'meas', prop: 'FuncRangeAuto', arg, cb: setDone, method: 'set' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getFuntMonitor = function getFuntMonitor(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else if (arg.mon1) {
resolve(self.meas.FuntMonitor1);
} else {
resolve(self.meas.FuntMonitor2);
}
}
const sysCmd = [];
if (arg.mon1 !== undefined) {
sysCmd.push({ id: 'meas', prop: 'FuntMonitor1', arg: '', cb: getDone, method: 'get' });
} else {
sysCmd.push({ id: 'meas', prop: 'FuntMonitor2', arg: '', cb: getDone, method: 'get' });
}
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setFuntMonitor = function setFuntMonitor(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [];
if (arg.mon1 !== undefined) {
sysCmd.push({ id: 'meas', prop: 'FuntMonitor1', arg: arg.mon1, cb: setDone, method: 'set' });
} else {
sysCmd.push({ id: 'meas', prop: 'FuntMonitor2', arg: arg.mon2, cb: setDone, method: 'set' });
}
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getFrequency = function getFrequency() {
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(self.sys.freq);
}
}
const sysCmd = [
{ id: 'sys', prop: 'Frequency', arg: '', cb: getDone, method: 'get' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setFrequency = function setFrequency(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [
{ id: 'sys', prop: 'Frequency', arg, cb: setDone, method: 'set' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getLevel = function getLevel(arg) {
const self = this;
return new Promise(((resolve, reject) => {
let cmdType;
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(self.sys.level[cmdType]);
}
}
const sysCmd = [];
if (arg.volt !== undefined) {
cmdType = 'volt';
sysCmd.push({ id: 'sys', prop: 'LevelVoltage', arg: '', cb: getDone, method: 'get' });
} else if (arg.curr !== undefined) {
cmdType = 'curr';
sysCmd.push({ id: 'sys', prop: 'LevelCurrent', arg: '', cb: getDone, method: 'get' });
} else if (arg.resist !== undefined) {
cmdType = 'resist';
sysCmd.push({ id: 'sys', prop: 'LevelSresistance', arg: '', cb: getDone, method: 'get' });
} else if (arg.mode !== undefined) {
cmdType = 'mode';
sysCmd.push({ id: 'sys', prop: 'LevelMode', arg: '', cb: getDone, method: 'get' });
} else if (arg.alc !== undefined) {
cmdType = 'alc';
sysCmd.push({ id: 'sys', prop: 'LevelALC', arg: '', cb: getDone, method: 'get' });
} else {
reject(`parameter ${arg} not support`);
return;
}
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setLevel = function setLevel(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [];
if (arg.volt !== undefined) {
sysCmd.push({ id: 'sys', prop: 'LevelVoltage', arg: arg.volt, cb: setDone, method: 'set' });
} else if (arg.curr !== undefined) {
sysCmd.push({ id: 'sys', prop: 'LevelCurrent', arg: arg.curr, cb: setDone, method: 'set' });
} else if (arg.resist !== undefined) {
sysCmd.push({ id: 'sys', prop: 'LevelSresistance', arg: arg.resist, cb: setDone, method: 'set' });
} else if (arg.alc !== undefined) {
sysCmd.push({ id: 'sys', prop: 'LevelALC', arg: arg.para, cb: setDone, method: 'set' });
} else {
reject(`parameter ${arg} not support`);
return;
}
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getAperture = function getAperture(arg) {
const self = this;
return new Promise(((resolve, reject) => {
let cmdType;
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(self.sys.level[cmdType]);
}
}
const sysCmd = [];
if (arg.rate !== undefined) {
cmdType = 'rate';
sysCmd.push({ id: 'sys', prop: 'ApertureRate', arg: '', cb: getDone, method: 'get' });
} else if (arg.avg !== undefined) {
cmdType = 'avg';
sysCmd.push({ id: 'sys', prop: 'ApertureAVG', arg: '', cb: getDone, method: 'get' });
} else {
reject(`parameter ${arg} not support`);
return;
}
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.setAperture = function setAperture(arg) {
const self = this;
return new Promise(((resolve, reject) => {
function setDone(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [];
if (arg.rate !== undefined) {
sysCmd.push({ id: 'sys', prop: 'SetApertureRate', arg: arg.rate, cb: setDone, method: 'set' });
} else if (arg.avg !== undefined) {
sysCmd.push({ id: 'sys', prop: 'SetApertureAVG', arg: arg.avg, cb: setDone, method: 'set' });
} else {
reject(`parameter ${arg} not support`);
return;
}
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
* The method belong to lcrctrl class used to set the device into local state
*
* @method force
*
*/
lcrctrl.setLocal = function setLocal() {
const self = this;
return new Promise(((resolve, reject) => {
function sysLocal(e) {
if (e) {
reject(e);
} else {
resolve();
}
}
const sysCmd = [
{ id: 'sys', prop: 'SysLocal', arg: '', cb: sysLocal, method: 'set' },
];
self.dev.cmdSequence = self.dev.cmdSequence.concat(sysCmd);
self.cmdEvent.emit('cmdWrite', sysCmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.getLcrMeas = function getLcrMeas(arg) {
// this.GetSnapshot(callback);
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else {
resolve(self.meas);
}
}
const cmd = [];
if (arg.impe !== undefined) {
cmd.push({ id: 'meas', prop: 'FetchImpedance', arg: '', cb: getDone, method: 'get' });
} else if (arg.main !== undefined) {
cmd.push({ id: 'meas', prop: 'FetchMain', arg: '', cb: getDone, method: 'get' });
} else if (arg.mon !== undefined) {
cmd.push({ id: 'meas', prop: 'FetchMonitor', arg: '', cb: getDone, method: 'get' });
} else if (arg.all !== undefined) {
cmd.push({ id: 'meas', prop: 'Function', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'meas', prop: 'FuntMonitor1', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'meas', prop: 'FuntMonitor2', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'meas', prop: 'FetchImpedance', arg: '', cb: getDone, method: 'get' });
} else {
log('LCR : getMeas do nothing');
reject(['DELAY_CNT', 'Parameter Error']);
return;
}
self.dev.cmdSequence = self.dev.cmdSequence.concat(cmd);
self.cmdEvent.emit('cmdWrite', cmd);
}));
}.bind(lcrObj);
/**
* used for url : /instrument/report/data/lcr
* Query Parameter : src1: primary , secondary, monitor1, monitor2
*/
lcrctrl.getMeas = function getMeas(arg) {
// this.GetSnapshot(callback);
const self = this;
return new Promise(((resolve, reject) => {
function getDone(e) {
if (e) {
reject(e);
} else {
let val;
if (self.meas.func.toUpperCase() === 'DCR') {
val = `DCR | ${self.meas.dcr}Ω`;
} else {
const measUnit = {
CS: 'F',
RS: 'Ω',
D: '',
CP: 'F',
RP: 'Ω',
LP: 'H',
Q: '',
R: 'Ω',
X: 'Ω',
DCR: 'Ω',
Z: 'Ω',
THR: 'r',
THD: '°',
ABS: 'Ω',
PER: '%',
};
const symbol = {
thr: 'r',
thd: 'θ',
abs: 'Δ',
per: 'Δ%',
};
const func = self.meas.func.split('-');
if (arg.src1.toUpperCase() === 'PRIMARY') {
val = `${func[0]} | ${self.meas.primary}${measUnit[func[0].toUpperCase()]}`;
} else if (arg.src1.toUpperCase() === 'SECONDARY') {
val = `${func[1]} | ${self.meas.secondary}${measUnit[func[1].toUpperCase()]}`;
} else if (arg.src1.toUpperCase() === 'MONITOR1') {
if (self.meas.FuntMonitor1 === 'abs' || self.meas.FuntMonitor1 === 'per') {
val = `${symbol[self.meas.FuntMonitor1]} | ${self.meas.mon1}${measUnit[self.meas.FuntMonitor1.toUpperCase()]}`;
} else {
val = `${self.meas.FuntMonitor1} | ${self.meas.mon1}${measUnit[self.meas.FuntMonitor1.toUpperCase()]}`;
}
} else if (self.meas.FuntMonitor2 === 'abs' || self.meas.FuntMonitor2 === 'per') {
val = `${symbol[self.meas.FuntMonitor2]} | ${self.meas.mon2}${measUnit[self.meas.FuntMonitor2.toUpperCase()]}`;
} else {
val = `${self.meas.FuntMonitor2} | ${self.meas.mon2}${measUnit[self.meas.FuntMonitor2.toUpperCase()]}`;
}
}
resolve(val);
}
}
const cmd = [];
cmd.push({ id: 'meas', prop: 'Function', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'meas', prop: 'FuntMonitor1', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'meas', prop: 'FuntMonitor2', arg: '', cb: null, method: 'get' });
cmd.push({ id: 'meas', prop: 'FetchImpedance', arg: '', cb: getDone, method: 'get' });
self.dev.cmdSequence = self.dev.cmdSequence.concat(cmd);
self.cmdEvent.emit('cmdWrite', cmd);
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.model = function model() {
const self = this;
return new Promise(((resolve) => {
const serialNumber = self.dev.usb.serialNumber;
resolve({ devModel: self.dev.gdsModel, serialNumber });
}));
}.bind(lcrObj);
/**
*
*/
lcrctrl.clearEvent = function clearEvent() {
const self = this;
return new Promise(((resolve) => {
if (self.dev.writeTimeoutObj) {
clearTimeout(self.dev.writeTimeoutObj);
}
self.dev.asyncWrite = 'done';
self.dev.queryBlock = false;
self.dev.state.setTimeout = false;
if (self.dev.state.timeoutObj) {
clearTimeout(self.dev.state.timeoutObj);
}
resolve();
}));
}.bind(lcrObj);
return lcrctrl;
}
async function cmdWrite() {
const self = this;
let cb = null;
const cmd = [];
async function sendCmd(cmdItem) {
return new Promise(((resolve, reject) => {
if (cmdItem.method === 'set') {
// log(self['sys']);
self[cmdItem.id].prop.set(cmdItem.prop, cmdItem.arg, (err) => {
if (err) {
reject(err);
return;
}
resolve();
});
} else {
self[cmdItem.id].prop.get(cmdItem.prop, cmdItem.arg, (err) => {
if (err) {
reject(err);
return;
}
resolve();
});
}
}));
}
log(this.dev.cmdSequence);
if (this.dev.asyncWrite === 'busy') {
log('async write busy');
log(this.dev.cmdSequence);
// if (this.dev.writeTimeoutObj === null) {
// log('set timeout retry cmdWrite');
// this.dev.writeTimeoutObj = setTimeout(function() {
// log('cmdWrite reissue');
// self.dev.writeTimeoutObj = null;
// //cmdWrite.call(self);
// self.cmdEvent.emit('cmdWrite', self.dev.cmdSequence);
// },400);
// }
return;
}
for (let i = 0, len = this.dev.cmdSequence.length; i < len; i += 1) {
cmd[i] = this.dev.cmdSequence.shift();
// avoid missing async callback, flush command buffer when find cb exist
if (cmd[i].cb !== null) {
cb = cmd[i].cb;
break;
}
}
if (self.dev.state.conn === 'disconnected') {
if (cb) {
cb('device disconnect');
}
self.dev.asyncWrite = 'done';
return;
}
if (cmd.length === 0) {
self.dev.asyncWrite = 'done';
return;
}
self.dev.asyncWrite = 'busy';
for (const cmdItem of cmd) {
try {
await sendCmd(cmdItem);
} catch (err) {
log(`send cmd ${cmdItem} error: ${err}`);
self.dev.usbDisconnect(() => {
self.dev.usbConnect(() => {
self.dev.cmdSequence = [];
self.dev.asyncWrite = 'done';
if (cb) {
cb(err);
}
});
});
return;
}
}
log('async/await write done');
if (self.dev.writeTimeoutObj) {
clearTimeout(self.dev.writeTimeoutObj);
}
self.dev.asyncWrite = 'done';
self.dev.state.conn = 'connected';
if (self.dev.cmdSequence.length !== 0) {
self.cmdEvent.emit('cmdWrite', self.dev.cmdSequence);
}
if (cb) {
cb();
}
// async.eachSeries(cmd,
// function(item,done) {
// log(item);
// if(item.method === 'set') {
// log(self['sys']);
// log("-------------------")
// self[item.id].prop.set(item.prop, item.arg, done);
// }else {
// try{
// self[item.id].prop.get(item.prop, item.arg, done);
// }
// catch(e){
// console.log(e);
// }
// }
// },function(err, results) {
// log('err: '+err);
// log('async write done');
// if(self.dev.writeTimeoutObj)
// clearTimeout(self.dev.writeTimeoutObj);
// if(err){
// self.dev.usbDisconnect( function(){
// self.dev.usbConnect( function(){
// self.dev.cmdSequence = [];
// self.dev.asyncWrite = 'done';
// if(cb)
// cb(err);
// });
// });
// return;
// }
// else{
// self.dev.asyncWrite = 'done';
// self.dev.state.conn = 'connected';
// if(self.dev.cmdSequence.length !== 0) {
// self.cmdEvent.emit('cmdWrite', self.dev.cmdSequence);
// }
// }
// if (cb)
// cb(err);
// }
// );
}
/**
* Create new instance that used to communicate with instrument through USB
*
* @class PwrUSB
* @constructor
* @extends lcrctrl
* @param {string} vid Vender ID bind to USB device
* @param {string} pid Product ID bind to USB device
*
* @return {Object} Return lcrctrl object
*/
exports.LcrUSB = function LcrUSB(device) {
const lcrObj = new LcdObject();
// log(lcrObj);
// log('PwrUSB:');
// log(lcrObj);
// if(lcrObj.dev.usbConnect)
// log('we have usbConnect');
// else
// log('we dont have usbConnect');
lcrObj.cmdEvent.on('cmdWrite', () => {
log('trigger cmdEvent');
cmdWrite.call(lcrObj);
});
usbDev.BindUsbObj(lcrObj.dev, device);
return LcrControl(lcrObj);
};