Source: DroneCommand.js

  1. const DroneCommandArgument = require('./DroneCommandArgument');
  2. const Enum = require('./util/Enum');
  3. const { characteristicSendUuids } = require('./CharacteristicEnums');
  5. /**
  6.  * Buffer types
  7.  *
  8.  * @property {number} ACK - Acknowledgment of previously received data
  9.  * @property {number} DATA - Normal data (no ack requested)
  10.  * @property {number} NON_ACK - Same as DATA
  11.  * @property {number} HIGH_PRIO - Not sure about this one could be LLD
  12.  * @property {number} LOW_LATENCY_DATA - Treated as normal data on the network, but are given higher priority internally
  13.  * @property {number} DATA_WITH_ACK - Data requesting an ack. The receiver must send an ack for this data unit!
  14.  *
  15.  * @type {Enum}
  16.  */
  17. const bufferType = new Enum({
  18.   ACK: 0x02,
  19.   DATA: 0x02,
  20.   NON_ACK: 0x02,
  21.   HIGH_PRIO: 0x02,
  22.   LOW_LATENCY_DATA: 0x03,
  23.   DATA_WITH_ACK: 0x04,
  24. });
  26. const bufferCharTranslationMap = new Enum({
  27.   ACK: 'ACK_COMMAND',
  28.   DATA: 'SEND_NO_ACK',
  29.   NON_ACK: 'SEND_NO_ACK',
  30.   HIGH_PRIO: 'SEND_HIGH_PRIORITY',
  31.   LOW_LATENCY_DATA: 'SEND_NO_ACK',
  32.   DATA_WITH_ACK: 'SEND_WITH_ACK',
  33. });
  35. /**
  36.  * Drone command
  37.  *
  38.  * Used for building commands to be sent to the drone. It
  39.  * is also used for the sensor readings.
  40.  *
  41.  * Arguments are automatically mapped on the object. This
  42.  * means that it is easy to set command arguments. Default
  43.  * arguments values are 0 or their enum equivalent by default.
  44.  *
  45.  * @example
  46.  * const parser = new CommandParser();
  47.  * const backFlip = parser.getCommand('minidrone', 'Animations', 'Flip', {direction: 'back'});
  48.  * const frontFlip = backFlip.clone();
  49.  *
  50.  * backFlip.direction = 'front';
  51.  *
  52.  * drone.runCommand(backFlip);
  53.  */
  54. class DroneCommand {
  55.   /**
  56.    * Creates a new DroneCommand instance
  57.    * @param {object} project - Project node from the xml spec
  58.    * @param {object} class_ - Class node from the xml spec
  59.    * @param {object} command - Command node from the xml spec
  60.    */
  61.   constructor(project, class_, command) {
  62.     this._project = project;
  63.     this._projectId = Number(project.$.id);
  64.     this._projectName = String(project.$.name);
  66.     this._class = class_;
  67.     this._classId = Number(class_.$.id);
  68.     this._className = String(class_.$.name);
  70.     this._command = command;
  71.     this._commandId = Number(command.$.id);
  72.     this._commandName = String(command.$.name);
  74.     this._deprecated = command.$.deprecated === 'true';
  75.     this._description = String(command._).trim();
  76.     this._arguments = (command.arg || []).map(x => new DroneCommandArgument(x));
  78.     // NON_ACK, ACK or HIGH_PRIO. Defaults to ACK
  79.     this._buffer = command.$.buffer || 'DATA_WITH_ACK';
  80.     this._timeout = command.$.timeout || 'POP';
  82.     this._mapArguments();
  83.   }
  85.   /**
  86.    * The project id
  87.    * @returns {number} - project id
  88.    */
  89.   get projectId() {
  90.     return this._projectId;
  91.   }
  93.   /**
  94.    * The project name (minidrone, common, etc)
  95.    * @returns {string} - project name
  96.    */
  97.   get projectName() {
  98.     return this._projectName;
  99.   }
  101.   /**
  102.    * The class id
  103.    * @returns {number} - class id
  104.    */
  105.   get classId() {
  106.     return this._classId;
  107.   }
  109.   /**
  110.    * The class name
  111.    * @returns {string} - class name
  112.    */
  113.   get className() {
  114.     return this._className;
  115.   }
  117.   /**
  118.    * The command id
  119.    * @returns {number} - command id
  120.    */
  121.   get commandId() {
  122.     return this._commandId;
  123.   }
  125.   /**
  126.    * The command name
  127.    * @returns {string} - command name
  128.    */
  129.   get commandName() {
  130.     return this._commandName;
  131.   }
  133.   /**
  134.    * Array containing the drone arguments
  135.    * @returns {DroneCommandArgument[]} - arguments
  136.    */
  137.   get arguments() {
  138.     return this._arguments;
  139.   }
  141.   /**
  142.    * Returns if the command has any arguments
  143.    * @returns {boolean} - command has any arguments
  144.    */
  145.   hasArguments() {
  146.     return this.arguments.length > 0;
  147.   }
  149.   /**
  150.    * Get the argument names. These names are also mapped to the instance
  151.    * @returns {string[]} - argument names
  152.    */
  153.   get argumentNames() {
  154.     return this.arguments.map(x => x.name);
  155.   }
  157.   /**
  158.    * Get the command description
  159.    * @returns {string} - command description
  160.    */
  161.   get description() {
  162.     return this._description;
  163.   }
  165.   /**
  166.    * Get if the command has been deprecated
  167.    * @returns {boolean} - deprecated
  168.    */
  169.   get deprecated() {
  170.     return this._deprecated;
  171.   }
  173.   /**
  174.    * Get the send characteristic uuid based on the buffer type
  175.    * @returns {string} - uuid as a string
  176.    */
  177.   get sendCharacteristicUuid() {
  178.     const t = bufferCharTranslationMap[this.bufferType] || 'SEND_WITH_ACK';
  180.     return 'fa' + characteristicSendUuids[t];
  181.   }
  183.   /**
  184.    * Checks if the command has a certain argument
  185.    * @param {string} key - Argument name
  186.    * @returns {boolean} - If the argument exists
  187.    */
  188.   hasArgument(key) {
  189.     return this.arguments.findIndex(x => x.name === key) !== -1;
  190.   }
  192.   /**
  193.    * Clones the instance
  194.    * @returns {DroneCommand} - Cloned instance
  195.    */
  196.   clone() {
  197.     const command = new this.constructor(this._project, this._class, this._command);
  199.     for (let i = 0; i < this.arguments.length; i++) {
  200.       command.arguments[i].value = this.arguments[i].value;
  201.     }
  203.     return command;
  204.   }
  206.   /**
  207.    * Converts the command to it's buffer representation
  208.    * @returns {Buffer} - Command buffer
  209.    * @throws TypeError
  210.    */
  211.   toBuffer() {
  212.     const bufferLength = 6 + this.arguments.reduce((acc, val) => val.getValueSize() + acc, 0);
  213.     const buffer = new Buffer(bufferLength);
  215.     buffer.fill(0);
  217.     buffer.writeUInt16LE(this.bufferFlag, 0);
  219.     // Skip command counter (offset 1) because it's set in DroneConnection::runCommand
  221.     buffer.writeUInt16LE(this.projectId, 2);
  222.     buffer.writeUInt16LE(this.classId, 3);
  223.     buffer.writeUInt16LE(this.commandId, 4); // two bytes
  225.     let bufferOffset = 6;
  227.     for (const arg of this.arguments) {
  228.       const valueSize = arg.getValueSize();
  230.       switch (arg.type) {
  231.         case 'u8':
  232.         case 'u16':
  233.         case 'u32':
  234.         case 'u64':
  235.           buffer.writeUIntLE(Math.floor(arg.value), bufferOffset, valueSize);
  236.           break;
  237.         case 'i8':
  238.         case 'i16':
  239.         case 'i32':
  240.         case 'i64':
  241.         case 'enum':
  242.           buffer.writeIntLE(Math.floor(arg.value), bufferOffset, valueSize);
  243.           break;
  244.         case 'string':
  245.           buffer.write(arg.value, bufferOffset, valueSize, 'ascii');
  246.           break;
  247.         case 'float':
  248.           buffer.writeFloatLE(arg.value, bufferOffset);
  249.           break;
  250.         case 'double':
  251.           buffer.writeDoubleLE(arg.value, bufferOffset);
  252.           break;
  253.         default:
  254.           throw new TypeError(`Can't encode buffer: unknown data type "${arg.type}" for argument "${arg.name}" in ${this.getToken()}`);
  255.       }
  257.       bufferOffset += valueSize;
  258.     }
  260.     return buffer;
  261.   }
  263.   /**
  264.    * Maps the arguments to the class
  265.    * @returns {void}
  266.    * @private
  267.    */
  268.   _mapArguments() {
  269.     for (const arg of this.arguments) {
  270.       const init = {
  271.         enumerable: false,
  272.         get: () => arg,
  273.         set: v => {
  274.           arg.value = v;
  275.         },
  276.       };
  278.       Object.defineProperty(this, arg.name, init);
  279.     }
  280.   }
  282.   /**
  283.    * Returns a string representation of a DroneCommand
  284.    * @param {boolean} debug - If extra debug information should be shown
  285.    * @returns {string} - String representation if the instance
  286.    * @example
  287.    * const str = command.toString();
  288.    *
  289.    * str === 'minidrone PilotingSettingsState PreferredPilotingModeChanged mode="medium"(1)';
  290.    * @example
  291.    * const str = command.toString(true);
  292.    *
  293.    * str === 'minidrone PilotingSettingsState PreferredPilotingModeChanged (enum)mode="medium"(1)';
  294.    */
  295.   toString(debug = false) {
  296.     const argStr = this.arguments.map(x => x.toString(debug)).join(' ').trim();
  298.     return `${this.getToken()} ${argStr}`.trim();
  299.   }
  301.   /**
  302.    * Get the command buffer type
  303.    * @returns {string} - Buffer type
  304.    */
  305.   get bufferType() {
  306.     return this._buffer.toUpperCase();
  307.   }
  309.   /**
  310.    * Get the command buffer flag based on it's type
  311.    * @returns {number} - Buffer flag
  312.    */
  313.   get bufferFlag() {
  314.     return bufferType[this.bufferType];
  315.   }
  317.   /**
  318.    * Indicates the required action to be taken in case the command times out
  319.    * The value of this attribute can be either POP, RETRY or FLUSH, defaulting to POP
  320.    * @returns {string} - Action name
  321.    */
  322.   get timeoutAction() {
  323.     return this._timeout;
  324.   }
  326.   /**
  327.    * Get the token representation of the command. This
  328.    * is useful for registering sensors for example
  329.    * @returns {string} - Command token
  330.    * @example
  331.    * const backFlip = parser.getCommand('minidrone', 'Animations', 'Flip', {direction: 'back'});
  332.    *
  333.    * backFlip.getToken() === 'minidrone-Animations-Flip';
  334.    */
  335.   getToken() {
  336.     return [this.projectName, this.className, this.commandName].join('-');
  337.   }
  338. }
  340. module.exports = DroneCommand;