Source: lib/node.js

  1. // Copyright (c) 2017 Intel Corporation. All rights reserved.
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. //     http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  15. 'use strict';
  17. const rclnodejs = require('bindings')('rclnodejs');
  18. const Timer = require('./timer.js');
  19. const Publisher = require('./publisher.js');
  20. const Subscription = require('./subscription.js');
  21. const Client = require('./client.js');
  22. const Service = require('./service.js');
  23. const QoS = require('./qos.js');
  24. const debug = require('debug')('rclnodejs:node');
  25. const loader = require('./interface_loader.js');
  26. const Context = require('./context.js');
  27. const GuardCondition = require('./guard_condition.js');
  28. /**
  29.  * @class - Class representing a Node in ROS
  30.  * @hideconstructor
  31.  */
  33. class Node {
  34.   init(name, namespace) {
  35.     this._publishers = [];
  36.     this._subscriptions = [];
  37.     this._clients = [];
  38.     this._services = [];
  39.     this._timers = [];
  40.     this._guards = [];
  41.     this._name = name;
  43.     if (namespace.length === 0) {
  44.       namespace = '/';
  45.     } else if (!namespace.startsWith('/')) {
  46.       namespace = '/' + namespace;
  47.     }
  48.     this._namespace = namespace;
  49.     this.spinning = false;
  50.   }
  52.   execute(handles) {
  53.     let timersReady = this._timers.filter((timer) => handles.indexOf(timer.handle) !== -1);
  54.     let guardsReady = this._guards.filter((guard) => handles.indexOf(guard.handle) !== -1);
  55.     let subscriptionsReady = this._subscriptions.filter((subscription) =>
  56.       handles.indexOf(subscription.handle) !== -1);
  57.     let clientsReady = this._clients.filter((client) => handles.indexOf(client.handle) !== -1);
  58.     let servicesReady = this._services.filter((service) => handles.indexOf(service.handle) !== -1);
  60.     timersReady.forEach((timer) => {
  61.       if (timer.isReady()) {
  62.         rclnodejs.callTimer(timer.handle);
  63.         timer.callback();
  64.       }
  65.     });
  67.     subscriptionsReady.forEach((subscription) => {
  68.       let Message = subscription.typeClass;
  69.       let msg = new Message();
  70.       let success = rclnodejs.rclTake(subscription.handle, msg.toRawROS());
  71.       if (success) {
  72.         subscription.processResponse(msg.refObject);
  73.       }
  74.       Message.destoryRawROS(msg);
  75.     });
  77.     guardsReady.forEach((guard) => {
  78.       guard.callback();
  79.     });
  81.     clientsReady.forEach((client) => {
  82.       let Response = client.typeClass.Response;
  83.       let response = new Response();
  84.       let success = rclnodejs.rclTakeResponse(client.handle, client.sequenceNumber, response.toRawROS());
  85.       if (success) {
  86.         client.processResponse(response.refObject);
  87.       }
  88.       Response.destoryRawROS(response);
  89.     });
  91.     servicesReady.forEach((service) => {
  92.       let Request = service.typeClass.Request;
  93.       let request = new Request();
  94.       let header = rclnodejs.rclTakeRequest(service.handle, this.handle, request.toRawROS());
  95.       if (header) {
  96.         service.processRequest(header, request.refObject);
  97.       }
  98.       Request.destoryRawROS(request);
  99.     });
  100.   }
  102.   startSpinning(context, timeout) {
  103.     this.start(context, timeout);
  104.     this.spinning = true;
  105.   }
  107.   stopSpinning() {
  108.     this.stop();
  109.     this.spinning = false;
  110.   }
  112.   _removeEntityFromArray(entity, array) {
  113.     let index = array.indexOf(entity);
  114.     if (index > -1) {
  115.       array.splice(index, 1);
  116.     }
  117.   }
  119.   _destroyEntity(entity, array, syncHandles = true) {
  120.     this._removeEntityFromArray(entity, array);
  121.     if (syncHandles) {
  122.       this.syncHandles();
  123.     }
  124.     entity.handle.release();
  125.   }
  127.   _validateOptions(options) {
  128.     if (options !== undefined &&
  129.         (options === null || typeof options !== 'object')) {
  130.       throw new TypeError('Invalid argument of options');
  131.     }
  133.     if (options === undefined) {
  134.       options = {enableTypedArray: true, qos: QoS.profileDefault};
  135.       return options;
  136.     }
  138.     if (options.enableTypedArray === undefined) {
  139.       options = Object.assign(options, {enableTypedArray: true});
  140.     }
  142.     if (options.qos === undefined) {
  143.       options = Object.assign(options, {qos: QoS.profileDefault});
  144.     }
  145.     return options;
  146.   }
  148.   /**
  149.    * Create a Timer.
  150.    * @param {number} period - The number representing period in millisecond.
  151.    * @param {function} callback - The callback to be called when timeout.
  152.    * @param {Context} context - The context, default is Context.defaultContext().
  153.    * @return {Timer} - An instance of Timer.
  154.    */
  155.   createTimer(period, callback, context = Context.defaultContext()) {
  156.     if (typeof (period) !== 'number' || typeof (callback) !== 'function') {
  157.       throw new TypeError('Invalid argument');
  158.     }
  160.     // The period unit is millisecond in JavaScript side. When being passed to the
  161.     // C++ side, the value will be converted to nanosecond, which goes into a uint64_t
  162.     // with maxmium value of 2^64-1. So the maxmium is UINT64_MAX in ns, that's 0x10c6f7a0b5ed in ms.
  163.     const MAX_TIMER_PERIOD_IN_MILLISECOND = 0x10c6f7a0b5ed;
  164.     if (period > 0x10c6f7a0b5ed || period < 0) {
  165.       throw new RangeError('Parameter must be between ' + 0 + ' and ' + MAX_TIMER_PERIOD_IN_MILLISECOND);
  166.     }
  168.     let timerHandle = rclnodejs.createTimer(period, context.handle());
  169.     let timer = new Timer(timerHandle, period, callback);
  170.     debug('Finish creating timer, period = %d.', period);
  171.     this._timers.push(timer);
  172.     this.syncHandles();
  174.     return timer;
  175.   }
  177.   /**
  178.    * Create a Publisher.
  179.    * @param {function|string|object} typeClass - The ROS message class,
  180.         OR a string representing the message class, e.g. 'std_msgs/msg/String',
  181.         OR an object representing the message class, e.g. {package: 'std_msgs', type: 'msg', name: 'String'}
  182.    * @param {string} topic - The name of the topic.
  183.    * @param {object} options - The options argument used to parameterize the publisher.
  184.    * @param {boolean} options.enableTypedArray - The topic will use TypedArray if necessary, default: true.
  185.    * @param {QoS} options.qos - ROS Middleware "quality of service" settings for the publisher, default: QoS.profileDefault.
  186.    * @return {Publisher} - An instance of Publisher.
  187.    */
  188.   createPublisher(typeClass, topic, options) {
  189.     if (typeof (typeClass) === 'string' || typeof (typeClass) === 'object') {
  190.       typeClass = loader.loadInterface(typeClass);
  191.     }
  192.     options = this._validateOptions(options);
  194.     if (typeof (typeClass) !== 'function' || typeof (topic) !== 'string') {
  195.       throw new TypeError('Invalid argument');
  196.     }
  198.     let publisher = Publisher.createPublisher(this.handle, typeClass, topic, options);
  199.     debug('Finish creating publisher, topic = %s.', topic);
  200.     this._publishers.push(publisher);
  201.     return publisher;
  202.   }
  204.   /**
  205.    * This callback is called when a message is published
  206.    * @callback SubscriptionCallback
  207.    * @param {Object} message - The message published
  208.    * @see [Node.createSubscription]{@link Node#createSubscription}
  209.    * @see [Node.createPublisher]{@link Node#createPublisher}
  210.    * @see {@link Publisher}
  211.    * @see {@link Subscription}
  212.    */
  214.   /**
  215.    * Create a Subscription.
  216.    * @param {function|string|object} typeClass - The ROS message class,
  217.         OR a string representing the message class, e.g. 'std_msgs/msg/String',
  218.         OR an object representing the message class, e.g. {package: 'std_msgs', type: 'msg', name: 'String'}
  219.    * @param {string} topic - The name of the topic.
  220.    * @param {object} options - The options argument used to parameterize the subscription.
  221.    * @param {boolean} options.enableTypedArray - The topic will use TypedArray if necessary, default: true.
  222.    * @param {QoS} options.qos - ROS Middleware "quality of service" settings for the subscription, default: QoS.profileDefault.
  223.    * @param {SubscriptionCallback} callback - The callback to be call when receiving the topic subscribed.
  224.    * @return {Subscription} - An instance of Subscription.
  225.    * @see {@link SubscriptionCallback}
  226.    */
  227.   createSubscription(typeClass, topic, options, callback) {
  228.     if (typeof (typeClass) === 'string' || typeof (typeClass) === 'object') {
  229.       typeClass = loader.loadInterface(typeClass);
  230.     }
  232.     if (typeof options === 'function') {
  233.       callback = options;
  234.       options = undefined;
  235.     }
  236.     options = this._validateOptions(options);
  238.     if (typeof (typeClass) !== 'function' || typeof (topic) !== 'string' || typeof (callback) !== 'function') {
  239.       throw new TypeError('Invalid argument');
  240.     }
  242.     let subscription = Subscription.createSubscription(this.handle, typeClass, topic, options, callback);
  243.     debug('Finish creating subscription, topic = %s.', topic);
  244.     this._subscriptions.push(subscription);
  245.     this.syncHandles();
  247.     return subscription;
  248.   }
  250.   /**
  251.    * Create a Client.
  252.    * @param {function|string|object} typeClass - The ROS message class,
  253.         OR a string representing the message class, e.g. 'std_msgs/msg/String',
  254.         OR an object representing the message class, e.g. {package: 'std_msgs', type: 'msg', name: 'String'}
  255.    * @param {string} serviceName - The service name to request.
  256.    * @param {object} options - The options argument used to parameterize the client.
  257.    * @param {boolean} options.enableTypedArray - The response will use TypedArray if necessary, default: true.
  258.    * @param {QoS} options.qos - ROS Middleware "quality of service" settings for the client, default: QoS.profileDefault.
  259.    * @return {Client} - An instance of Client.
  260.    */
  261.   createClient(typeClass, serviceName, options) {
  262.     if (typeof (typeClass) === 'string' || typeof (typeClass) === 'object') {
  263.       typeClass = loader.loadInterface(typeClass);
  264.     }
  265.     options = this._validateOptions(options);
  267.     if (typeof (typeClass) !== 'function' || typeof (serviceName) !== 'string') {
  268.       throw new TypeError('Invalid argument');
  269.     }
  271.     let client = Client.createClient(this.handle, serviceName, typeClass, options);
  272.     debug('Finish creating client, service = %s.', serviceName);
  273.     this._clients.push(client);
  274.     this.syncHandles();
  276.     return client;
  277.   }
  279.   /**
  280.    * This callback is called when a request is sent to service
  281.    * @callback RequestCallback
  282.    * @param {Object} request - The request sent to the service
  283.    * @param {Response} response - The response to client.
  284.         Use [response.send()]{@link Response#send} to send response object to client
  285.    * @return {undefined}
  286.    * @see [Node.createService]{@link Node#createService}
  287.    * @see [Client.sendRequest]{@link Client#sendRequest}
  288.    * @see {@link Client}
  289.    * @see {@link Service}
  290.    * @see {@link Response#send}
  291.    */
  293.   /**
  294.    * Create a Service.
  295.    * @param {function|string|object} typeClass - The ROS message class,
  296.         OR a string representing the message class, e.g. 'std_msgs/msg/String',
  297.         OR an object representing the message class, e.g. {package: 'std_msgs', type: 'msg', name: 'String'}
  298.    * @param {string} serviceName - The service name to offer.
  299.    * @param {object} options - The options argument used to parameterize the service.
  300.    * @param {boolean} options.enableTypedArray - The request will use TypedArray if necessary, default: true.
  301.    * @param {QoS} options.qos - ROS Middleware "quality of service" settings for the service, default: QoS.profileDefault.
  302.    * @param {RequestCallback} callback - The callback to be called when receiving request.
  303.    * @return {Service} - An instance of Service.
  304.    * @see {@link RequestCallback}
  305.    */
  306.   createService(typeClass, serviceName, options, callback) {
  307.     if (typeof (typeClass) === 'string' || typeof (typeClass) === 'object') {
  308.       typeClass = loader.loadInterface(typeClass);
  309.     }
  311.     if (typeof options === 'function') {
  312.       callback = options;
  313.       options = undefined;
  314.     }
  315.     options = this._validateOptions(options);
  317.     if (typeof (typeClass) !== 'function' || typeof (serviceName) !== 'string' || typeof (callback) !== 'function') {
  318.       throw new TypeError('Invalid argument');
  319.     }
  321.     let service = Service.createService(this.handle, serviceName, typeClass, options, callback);
  322.     debug('Finish creating service, service = %s.', serviceName);
  323.     this._services.push(service);
  324.     this.syncHandles();
  326.     return service;
  327.   }
  329.   /**
  330.    * Create a guard condition.
  331.    * @param {Function} callback - The callback to be called when the guard condition is triggered.
  332.    * @return {GuardCondition} - An instance of GuardCondition.
  333.    */
  334.   createGuardCondition(callback) {
  335.     if (typeof (callback) !== 'function') {
  336.       throw new TypeError('Invalid argument');
  337.     }
  339.     let guard = GuardCondition.createGuardCondition(callback, this.context);
  340.     debug('Finish creating guard condition');
  341.     this._guards.push(guard);
  342.     this.syncHandles();
  344.     return guard;
  345.   }
  347.   /**
  348.    * Destroy all resource allocated by this node, including
  349.    * <code>Timer</code>s/<code>Publisher</code>s/<code>Subscription</code>s
  350.    * /<code>Client</code>s/<code>Service</code>s
  351.    * @return {undefined}
  352.    */
  353.   destroy() {
  354.     if (this.spinning) {
  355.       this.stopSpinning();
  356.     }
  358.     this.handle.release();
  359.     this._timers = [];
  360.     this._publishers = [];
  361.     this._subscriptions = [];
  362.     this._clients = [];
  363.     this._services = [];
  364.     this._guards = [];
  365.   }
  367.   /**
  368.    * Destroy a Publisher.
  369.    * @param {Publisher} publisher - The Publisher to be destroyed.
  370.    * @return {undefined}
  371.    */
  372.   destroyPublisher(publisher) {
  373.     if (!(publisher instanceof Publisher)) {
  374.       throw new TypeError('Invalid argument');
  375.     }
  376.     this._destroyEntity(publisher, this._publishers, false);
  377.   }
  379.   /**
  380.    * Destroy a Subscription.
  381.    * @param {Subscription} subscription - The Subscription to be destroyed.
  382.    * @return {undefined}
  383.    */
  384.   destroySubscription(subscription) {
  385.     if (!(subscription instanceof Subscription)) {
  386.       throw new TypeError('Invalid argument');
  387.     }
  388.     this._destroyEntity(subscription, this._subscriptions);
  389.   }
  391.   /**
  392.    * Destroy a Client.
  393.    * @param {Client} client - The Client to be destroyed.
  394.    * @return {undefined}
  395.    */
  396.   destroyClient(client) {
  397.     if (!(client instanceof Client)) {
  398.       throw new TypeError('Invalid argument');
  399.     }
  400.     this._destroyEntity(client, this._clients);
  401.   }
  403.   /**
  404.    * Destroy a Service.
  405.    * @param {Service} service - The Service to be destroyed.
  406.    * @return {undefined}
  407.    */
  408.   destroyService(service) {
  409.     if (!(service instanceof Service)) {
  410.       throw new TypeError('Invalid argument');
  411.     }
  412.     this._destroyEntity(service, this._services);
  413.   }
  415.   /**
  416.    * Destroy a Timer.
  417.    * @param {Timer} timer - The Timer to be destroyed.
  418.    * @return {undefined}
  419.    */
  420.   destroyTimer(timer) {
  421.     if (!(timer instanceof Timer)) {
  422.       throw new TypeError('Invalid argument');
  423.     }
  424.     this._destroyEntity(timer, this._timers);
  425.   }
  427.   /**
  428.    * Destroy a guard condition.
  429.    * @param {GuardCondition} guard - The guard condition to be destroyed.
  430.    * @return {undefined}
  431.    */
  432.   destroyGuardCondition(guard) {
  433.     if (!(guard instanceof GuardCondition)) {
  434.       throw new TypeError('Invalid argument');
  435.     }
  436.     this._destroyEntity(guard, this._guards);
  437.   }
  439.   /* Get the name of the node.
  440.    * @return {string}
  441.    */
  442.   name() {
  443.     return rclnodejs.getNodeName(this.handle);
  444.   }
  446.   /* Get the namespace of the node.
  447.    * @return {string}
  448.    */
  449.   namespace() {
  450.     return rclnodejs.getNamespace(this.handle);
  451.   }
  453.   /**
  454.    * Get the list of published topics discovered by the provided node for the remote node name.
  455.    * @param {string} nodeName - The name of the node.
  456.    * @param {string} namespace - The name of the namespace.
  457.    * @param {boolean} noDemangle - If true topic names and types returned will not be demangled, default: false.
  458.    * @return {array} - An array of the names and types.
  459.    */
  460.   getPublisherNamesAndTypesByNode(nodeName, namespace, noDemangle = false) {
  461.     return rclnodejs.getPublisherNamesAndTypesByNode(this.handle, nodeName, namespace, noDemangle);
  462.   }
  464.   /**
  465.    * Get the list of published topics discovered by the provided node for the remote node name.
  466.    * @param {string} nodeName - The name of the node.
  467.    * @param {string} namespace - The name of the namespace.
  468.    * @param {boolean} noDemangle - If true topic names and types returned will not be demangled, default: false.
  469.    * @return {array} - An array of the names and types.
  470.    */
  471.   getSubscriptionNamesAndTypesByNode(nodeName, namespace, noDemangle = false) {
  472.     return rclnodejs.getSubscriptionNamesAndTypesByNode(this.handle, nodeName, namespace, noDemangle);
  473.   }
  475.   /**
  476.    * Get the list of service topics discovered by the provided node for the remote node name.
  477.    * @param {string} nodeName - The name of the node.
  478.    * @param {string} namespace - The name of the namespace.
  479.    * @return {array} - An array of the names and types.
  480.    */
  481.   getServiceNamesAndTypesByNode(nodeName, namespace) {
  482.     return rclnodejs.getServiceNamesAndTypesByNode(this.handle, nodeName, namespace);
  483.   }
  485.   /**
  486.    * Get the list of topics discovered by the provided node.
  487.    * @param {boolean} noDemangle - If true topic names and types returned will not be demangled, default: false.
  488.    * @return {array} - An array of the names and types.
  489.    */
  490.   getTopicNamesAndTypes(noDemangle = false) {
  491.     return rclnodejs.getTopicNamesAndTypes(this.handle, noDemangle);
  492.   }
  494.   /**
  495.    * Get the list of services discovered by the provided node.
  496.    * @return {array} - An array of the names and types.
  497.    */
  498.   getServiceNamesAndTypes() {
  499.     return rclnodejs.getServiceNamesAndTypes(this.handle);
  500.   }
  502.   /**
  503.    * Get the list of nodes discovered by the provided node.
  504.    * @return {array} - An array of the names.
  505.    */
  506.   getNodeNames() {
  507.     return this.getNodeNamesAndNamespaces().map(item => item.name);
  508.   }
  510.   /**
  511.    * Get the list of nodes and their namespaces discovered by the provided node.
  512.    * @return {array} - An array of the names and namespaces.
  513.    */
  514.   getNodeNamesAndNamespaces() {
  515.     return rclnodejs.getNodeNames(this.handle);
  516.   }
  518.   /**
  519.    * Return the number of publishers on a given topic.
  520.    * @param {string} topic - The name of the topic.
  521.    * @returns {number} - Number of publishers on the given topic.
  522.    */
  523.   countPublishers(topic) {
  524.     let expandedTopic = rclnodejs.expandTopicName(topic, this._name, this._namespace);
  525.     rclnodejs.validateTopicName(expandedTopic);
  527.     return rclnodejs.countPublishers(this.handle, expandedTopic);
  528.   }
  530.   /**
  531.    * Return the number of subscribers on a given topic.
  532.    * @param {string} topic - The name of the topic.
  533.    * @returns {number} - Number of subscribers on the given topic.
  534.    */
  535.   countSubscribers(topic) {
  536.     let expandedTopic = rclnodejs.expandTopicName(topic, this._name, this._namespace);
  537.     rclnodejs.validateTopicName(expandedTopic);
  539.     return rclnodejs.countSubscribers(this.handle, expandedTopic);
  540.   }
  541. }
  543. module.exports = Node;