@digipair/skill-mybuddy 0.23.10 → 0.23.11

package/index.cjs.js

@@ -8,6 +8,7 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var mybuddy__default = /*#__PURE__*/_interopDefaultLegacy(mybuddy);
 
+const TIMEOUT_READ_COMMANDS = 1000;
 let MyBuddyService = class MyBuddyService {
     async connect(params, context) {
         var _context_privates_MY_BUDDY;
@@ -228,224 +229,326 @@ let MyBuddyService = class MyBuddyService {
     // Data Retrieval
     async getAngles(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ANGLES, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ANGLES, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].getAngles(device));
         });
-        connection.write(mybuddy__default["default"].getAngles(device));
-        return data;
     }
     async isPowerOn(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_POWER_ON, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_POWER_ON, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].isPowerOn(device));
         });
-        connection.write(mybuddy__default["default"].isPowerOn(device));
-        return data;
     }
     async isControllerConnect(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_CONTROLLER_CONNECTED, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_CONTROLLER_CONNECTED, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].isControllerConnect());
         });
-        connection.write(mybuddy__default["default"].isControllerConnect());
-        return data;
     }
     async getCoords(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_COORDS, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_COORDS, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].getCoords(device));
         });
-        connection.write(mybuddy__default["default"].getCoords(device));
-        return data;
     }
     async isInPosition(params, _pinsSettingsList, context) {
         const { device, data, flag } = params;
-        let result = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_IN_POSITION, 16)) {
-                result = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_IN_POSITION, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].isInPosition(device, data, flag));
         });
-        connection.write(mybuddy__default["default"].isInPosition(device, data, flag));
-        return result;
     }
     async getEncoder(params, _pinsSettingsList, context) {
         const { device, joint_id } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ENCODER, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ENCODER, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].getEncoder(device, joint_id));
         });
-        connection.write(mybuddy__default["default"].getEncoder(device, joint_id));
-        return data;
     }
     async getEncoders(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ENCODER, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ENCODER, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].getEncoders(device));
         });
-        connection.write(mybuddy__default["default"].getEncoders(device));
-        return data;
     }
     async getSpeed(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_SPEED, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_SPEED, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].getSpeed(device));
         });
-        connection.write(mybuddy__default["default"].getSpeed(device));
-        return data;
     }
     async getJointMin(params, _pinsSettingsList, context) {
         const { device, joint_id } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_JOINT_MIN_ANGLE, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_JOINT_MIN_ANGLE, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].getJointMin(device, joint_id));
         });
-        connection.write(mybuddy__default["default"].getJointMin(device, joint_id));
-        return data;
     }
     async getJointMax(params, _pinsSettingsList, context) {
         const { device, joint_id } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_JOINT_MAX_ANGLE, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_JOINT_MAX_ANGLE, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].getJointMax(device, joint_id));
         });
-        connection.write(mybuddy__default["default"].getJointMax(device, joint_id));
-        return data;
     }
     async isServoEnable(params, _pinsSettingsList, context) {
         const { device, servo_id } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_SERVO_ENABLE, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_SERVO_ENABLE, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].isServoEnable(device, servo_id));
         });
-        connection.write(mybuddy__default["default"].isServoEnable(device, servo_id));
-        return data;
     }
     async isAllServoEnable(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_ALL_SERVO_ENABLE, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_ALL_SERVO_ENABLE, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].isAllServoEnable(device));
         });
-        connection.write(mybuddy__default["default"].isAllServoEnable(device));
-        return data;
     }
     async getServodata(params, _pinsSettingsList, context) {
         const { device, servo_no, data_id } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_SERVO_DATA, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_SERVO_DATA, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].getServodata(device, servo_no, data_id));
         });
-        connection.write(mybuddy__default["default"].getServodata(device, servo_no, data_id));
-        return data;
     }
     async getDigitalInput(params, _pinsSettingsList, context) {
         const { device, pin_no } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_DIGITAL_INPUT, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_DIGITAL_INPUT, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].getDigitalInput(device, pin_no));
         });
-        connection.write(mybuddy__default["default"].getDigitalInput(device, pin_no));
-        return data;
     }
     async getGripperValue(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_GRIPPER_VALUE, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_GRIPPER_VALUE, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].getGripperValue(device));
         });
-        connection.write(mybuddy__default["default"].getGripperValue(device));
-        return data;
     }
     async getBasicOutput(params, _pinsSettingsList, context) {
         const { device, pin_no } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_BASIC_INPUT, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_BASIC_INPUT, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].getBasicOutput(device, pin_no));
         });
-        connection.write(mybuddy__default["default"].getBasicOutput(device, pin_no));
-        return data;
     }
     async isGripperMoving(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_GRIPPER_MOVING, 16)) {
-                data = mybuddy__default["default"].processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_GRIPPER_MOVING, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy__default["default"].processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy__default["default"].isGripperMoving(device));
         });
-        connection.write(mybuddy__default["default"].isGripperMoving(device));
-        return data;
     }
     // TOOLS
     async sleep(params, _pinsSettingsList, context) {

package/index.esm.js

@@ -1,5 +1,6 @@
 import mybuddy from '@marcbuils/mybuddy';
 
+const TIMEOUT_READ_COMMANDS = 1000;
 let MyBuddyService = class MyBuddyService {
     async connect(params, context) {
         var _context_privates_MY_BUDDY;
@@ -220,224 +221,326 @@ let MyBuddyService = class MyBuddyService {
     // Data Retrieval
     async getAngles(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_ANGLES, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_ANGLES, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.getAngles(device));
         });
-        connection.write(mybuddy.getAngles(device));
-        return data;
     }
     async isPowerOn(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_POWER_ON, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_POWER_ON, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.isPowerOn(device));
         });
-        connection.write(mybuddy.isPowerOn(device));
-        return data;
     }
     async isControllerConnect(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_CONTROLLER_CONNECTED, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_CONTROLLER_CONNECTED, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.isControllerConnect());
         });
-        connection.write(mybuddy.isControllerConnect());
-        return data;
     }
     async getCoords(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_COORDS, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_COORDS, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.getCoords(device));
         });
-        connection.write(mybuddy.getCoords(device));
-        return data;
     }
     async isInPosition(params, _pinsSettingsList, context) {
         const { device, data, flag } = params;
-        let result = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_IN_POSITION, 16)) {
-                result = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_IN_POSITION, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.isInPosition(device, data, flag));
         });
-        connection.write(mybuddy.isInPosition(device, data, flag));
-        return result;
     }
     async getEncoder(params, _pinsSettingsList, context) {
         const { device, joint_id } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_ENCODER, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_ENCODER, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.getEncoder(device, joint_id));
         });
-        connection.write(mybuddy.getEncoder(device, joint_id));
-        return data;
     }
     async getEncoders(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_ENCODER, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_ENCODER, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.getEncoders(device));
         });
-        connection.write(mybuddy.getEncoders(device));
-        return data;
     }
     async getSpeed(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_SPEED, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_SPEED, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.getSpeed(device));
         });
-        connection.write(mybuddy.getSpeed(device));
-        return data;
     }
     async getJointMin(params, _pinsSettingsList, context) {
         const { device, joint_id } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_JOINT_MIN_ANGLE, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_JOINT_MIN_ANGLE, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.getJointMin(device, joint_id));
         });
-        connection.write(mybuddy.getJointMin(device, joint_id));
-        return data;
     }
     async getJointMax(params, _pinsSettingsList, context) {
         const { device, joint_id } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_JOINT_MAX_ANGLE, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_JOINT_MAX_ANGLE, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.getJointMax(device, joint_id));
         });
-        connection.write(mybuddy.getJointMax(device, joint_id));
-        return data;
     }
     async isServoEnable(params, _pinsSettingsList, context) {
         const { device, servo_id } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_SERVO_ENABLE, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_SERVO_ENABLE, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.isServoEnable(device, servo_id));
         });
-        connection.write(mybuddy.isServoEnable(device, servo_id));
-        return data;
     }
     async isAllServoEnable(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_ALL_SERVO_ENABLE, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_ALL_SERVO_ENABLE, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.isAllServoEnable(device));
         });
-        connection.write(mybuddy.isAllServoEnable(device));
-        return data;
     }
     async getServodata(params, _pinsSettingsList, context) {
         const { device, servo_no, data_id } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_SERVO_DATA, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_SERVO_DATA, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.getServodata(device, servo_no, data_id));
         });
-        connection.write(mybuddy.getServodata(device, servo_no, data_id));
-        return data;
     }
     async getDigitalInput(params, _pinsSettingsList, context) {
         const { device, pin_no } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_DIGITAL_INPUT, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_DIGITAL_INPUT, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.getDigitalInput(device, pin_no));
         });
-        connection.write(mybuddy.getDigitalInput(device, pin_no));
-        return data;
     }
     async getGripperValue(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_GRIPPER_VALUE, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_GRIPPER_VALUE, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.getGripperValue(device));
         });
-        connection.write(mybuddy.getGripperValue(device));
-        return data;
     }
     async getBasicOutput(params, _pinsSettingsList, context) {
         const { device, pin_no } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_BASIC_INPUT, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.GET_BASIC_INPUT, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.getBasicOutput(device, pin_no));
         });
-        connection.write(mybuddy.getBasicOutput(device, pin_no));
-        return data;
     }
     async isGripperMoving(params, _pinsSettingsList, context) {
         const { device } = params;
-        let data = null;
         const connection = await this.connect(params, context);
-        connection.on('data', (data)=>{
-            if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_GRIPPER_MOVING, 16)) {
-                data = mybuddy.processReceived(data);
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
                 connection.close();
-            }
+                reject('TIMEOUT_READ_COMMANDS');
+            }, TIMEOUT_READ_COMMANDS);
+            connection.on('data', (data)=>{
+                if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy.COMMAND.IS_GRIPPER_MOVING, 16)) {
+                    clearTimeout(timeoutId);
+                    const result = mybuddy.processReceived(data);
+                    connection.close();
+                    resolve(result);
+                }
+            });
+            connection.write(mybuddy.isGripperMoving(device));
         });
-        connection.write(mybuddy.isGripperMoving(device));
-        return data;
     }
     // TOOLS
     async sleep(params, _pinsSettingsList, context) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digipair/skill-mybuddy",
-  "version": "0.23.10",
+  "version": "0.23.11",
   "dependencies": {
     "@marcbuils/mybuddy": "^0.0.9"
   },

package/{libs/skill-mybuddy/src → src}/lib/skill-mybuddy.d.ts

@@ -1,6 +1,6 @@
 import { PinsSettings } from '@digipair/engine';
 export declare const sendAngles: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
-export declare const getAngles: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
+export declare const getAngles: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
 export declare const powerOn: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
 export declare const powerOff: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
 export declare const releaseAllServos: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
@@ -26,20 +26,20 @@ export declare const setGripperValue: (params: any, pinsSettingsList: PinsSettin
 export declare const setGripperIni: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
 export declare const setBasicOutput: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
 export declare const setColor: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
-export declare const isPowerOn: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const isControllerConnect: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const getCoords: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const isInPosition: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const getEncoder: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const getEncoders: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const getSpeed: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const getJointMin: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const getJointMax: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const isServoEnable: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const isAllServoEnable: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const getServodata: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const getDigitalInput: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const getGripperValue: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const getBasicOutput: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
-export declare const isGripperMoving: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<null>;
+export declare const isPowerOn: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const isControllerConnect: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const getCoords: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const isInPosition: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const getEncoder: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const getEncoders: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const getSpeed: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const getJointMin: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const getJointMax: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const isServoEnable: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const isAllServoEnable: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const getServodata: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const getDigitalInput: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const getGripperValue: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const getBasicOutput: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
+export declare const isGripperMoving: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<unknown>;
 export declare const sleep: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;