@digipair/skill-mybuddy 0.23.10 → 0.23.12

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;
@@ -51,15 +52,23 @@ let MyBuddyService = class MyBuddyService {
         return result;
     }
     async sendAngle(params, _pinsSettingsList, context) {
-        const { device, id = 1, degree = 0, speed = 60 } = params;
+        const { device, id, degree, speed = 50 } = params;
         const connection = await this.connect(params, context);
         const result = connection.write(mybuddy__default["default"].sendAngle(device, id, degree, speed));
         await new Promise((resolve)=>setTimeout(resolve, 50));
         connection.close();
         return result;
     }
+    async sendCoord(params, _pinsSettingsList, context) {
+        const { device, id, coord, speed = 50 } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].sendCoord(device, id, coord, speed));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
     async sendCoords(params, _pinsSettingsList, context) {
-        const { device, coords, speed, mode } = params;
+        const { device, coords, speed = 50, mode = 0 } = params;
         const connection = await this.connect(params, context);
         const result = connection.write(mybuddy__default["default"].sendCoords(device, coords, speed, mode));
         await new Promise((resolve)=>setTimeout(resolve, 50));
@@ -228,224 +237,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) {
@@ -461,6 +572,7 @@ const powerOn = (params, pinsSettingsList, context)=>new MyBuddyService().powerO
 const powerOff = (params, pinsSettingsList, context)=>new MyBuddyService().powerOff(params, pinsSettingsList, context);
 const releaseAllServos = (params, pinsSettingsList, context)=>new MyBuddyService().releaseAllServos(params, pinsSettingsList, context);
 const sendAngle = (params, pinsSettingsList, context)=>new MyBuddyService().sendAngle(params, pinsSettingsList, context);
+const sendCoord = (params, pinsSettingsList, context)=>new MyBuddyService().sendCoord(params, pinsSettingsList, context);
 const sendCoords = (params, pinsSettingsList, context)=>new MyBuddyService().sendCoords(params, pinsSettingsList, context);
 const programPause = (params, pinsSettingsList, context)=>new MyBuddyService().programPause(params, pinsSettingsList, context);
 const programResume = (params, pinsSettingsList, context)=>new MyBuddyService().programResume(params, pinsSettingsList, context);
@@ -529,6 +641,7 @@ exports.releaseAllServos = releaseAllServos;
 exports.releaseServo = releaseServo;
 exports.sendAngle = sendAngle;
 exports.sendAngles = sendAngles;
+exports.sendCoord = sendCoord;
 exports.sendCoords = sendCoords;
 exports.setBasicOutput = setBasicOutput;
 exports.setColor = setColor;

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;
@@ -43,15 +44,23 @@ let MyBuddyService = class MyBuddyService {
         return result;
     }
     async sendAngle(params, _pinsSettingsList, context) {
-        const { device, id = 1, degree = 0, speed = 60 } = params;
+        const { device, id, degree, speed = 50 } = params;
         const connection = await this.connect(params, context);
         const result = connection.write(mybuddy.sendAngle(device, id, degree, speed));
         await new Promise((resolve)=>setTimeout(resolve, 50));
         connection.close();
         return result;
     }
+    async sendCoord(params, _pinsSettingsList, context) {
+        const { device, id, coord, speed = 50 } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy.sendCoord(device, id, coord, speed));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
     async sendCoords(params, _pinsSettingsList, context) {
-        const { device, coords, speed, mode } = params;
+        const { device, coords, speed = 50, mode = 0 } = params;
         const connection = await this.connect(params, context);
         const result = connection.write(mybuddy.sendCoords(device, coords, speed, mode));
         await new Promise((resolve)=>setTimeout(resolve, 50));
@@ -220,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.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) {
@@ -453,6 +564,7 @@ const powerOn = (params, pinsSettingsList, context)=>new MyBuddyService().powerO
 const powerOff = (params, pinsSettingsList, context)=>new MyBuddyService().powerOff(params, pinsSettingsList, context);
 const releaseAllServos = (params, pinsSettingsList, context)=>new MyBuddyService().releaseAllServos(params, pinsSettingsList, context);
 const sendAngle = (params, pinsSettingsList, context)=>new MyBuddyService().sendAngle(params, pinsSettingsList, context);
+const sendCoord = (params, pinsSettingsList, context)=>new MyBuddyService().sendCoord(params, pinsSettingsList, context);
 const sendCoords = (params, pinsSettingsList, context)=>new MyBuddyService().sendCoords(params, pinsSettingsList, context);
 const programPause = (params, pinsSettingsList, context)=>new MyBuddyService().programPause(params, pinsSettingsList, context);
 const programResume = (params, pinsSettingsList, context)=>new MyBuddyService().programResume(params, pinsSettingsList, context);
@@ -492,4 +604,4 @@ const getBasicOutput = (params, pinsSettingsList, context)=>new MyBuddyService()
 const isGripperMoving = (params, pinsSettingsList, context)=>new MyBuddyService().isGripperMoving(params, pinsSettingsList, context);
 const sleep = (params, pinsSettingsList, context)=>new MyBuddyService().sleep(params, pinsSettingsList, context);
 
-export { focusServo, getAngles, getBasicOutput, getCoords, getDigitalInput, getEncoder, getEncoders, getGripperValue, getJointMax, getJointMin, getServodata, getSpeed, isAllServoEnable, isControllerConnect, isGripperMoving, isInPosition, isPowerOn, isServoEnable, jogAngle, jogCoord, jogStop, powerOff, powerOn, programPause, programResume, releaseAllServos, releaseServo, sendAngle, sendAngles, sendCoords, setBasicOutput, setColor, setDigitalOutput, setEncoder, setEncoders, setGripperIni, setGripperState, setGripperValue, setPinMode, setServoCalibration, setServoData, setSpeed, sleep, stop };
+export { focusServo, getAngles, getBasicOutput, getCoords, getDigitalInput, getEncoder, getEncoders, getGripperValue, getJointMax, getJointMin, getServodata, getSpeed, isAllServoEnable, isControllerConnect, isGripperMoving, isInPosition, isPowerOn, isServoEnable, jogAngle, jogCoord, jogStop, powerOff, powerOn, programPause, programResume, releaseAllServos, releaseServo, sendAngle, sendAngles, sendCoord, sendCoords, setBasicOutput, setColor, setDigitalOutput, setEncoder, setEncoders, setGripperIni, setGripperState, setGripperValue, setPinMode, setServoCalibration, setServoData, setSpeed, sleep, stop };

package/package.json

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

package/schema.json

@@ -164,6 +164,51 @@
         "x-events": []
       }
     },
+    "/sendCoord": {
+      "post": {
+        "tags": ["service"],
+        "summary": "Envoie les coordonnées",
+        "parameters": [
+          {
+            "name": "device",
+            "summary": "Identifiant du device",
+            "required": true,
+            "description": "Identifiant du device concerné (0 = Tous, 1 = Bras gauche, 2 = Bras droit, 3 = Corps)",
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "id",
+            "summary": "Coordonnée à modifier",
+            "required": true,
+            "description": "Identifiant de la coordonnée à envoyer",
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "coord",
+            "summary": "Valeur",
+            "required": true,
+            "description": "Valeur de la coordonnée à envoyer",
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "speed",
+            "summary": "Vitesse",
+            "required": false,
+            "description": "Vitesse de déplacement",
+            "schema": {
+              "type": "number"
+            }
+          }
+        ],
+        "x-events": []
+      }
+    },
     "/sendCoords": {
       "post": {
         "tags": ["service"],

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

@@ -1,10 +1,11 @@
 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>;
 export declare const sendAngle: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
+export declare const sendCoord: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
 export declare const sendCoords: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
 export declare const programPause: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
 export declare const programResume: (params: any, pinsSettingsList: PinsSettings[], context: any) => Promise<any>;
@@ -26,20 +27,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>;