@digipair/skill-mybuddy 0.91.0-0 → 0.92.0

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.js

@@ -0,0 +1,659 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var mybuddy = require('@marcbuils/mybuddy');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var mybuddy__default = /*#__PURE__*/_interopDefaultLegacy(mybuddy);
+
+const TIMEOUT_READ_COMMANDS = 1000;
+let MyBuddyService = class MyBuddyService {
+    async connect(params, context) {
+        var _context_privates_MY_BUDDY;
+        const { MY_BUDDY = (_context_privates_MY_BUDDY = context.privates.MY_BUDDY) != null ? _context_privates_MY_BUDDY : {
+            port: '/dev/ttyACM0',
+            baud: 115200
+        } } = params;
+        return mybuddy__default["default"].connect(MY_BUDDY.port, MY_BUDDY.baud);
+    }
+    // Actions
+    async sendAngles(params, _pinsSettingsList, context) {
+        const { device, angles, speed = 50 } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].sendAngles(device, angles, speed));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async powerOn(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].powerOn(device));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async powerOff(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].powerOff(device));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async releaseAllServos(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].releaseAllServos(device));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async sendAngle(params, _pinsSettingsList, context) {
+        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 = 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));
+        connection.close();
+        return result;
+    }
+    async programPause(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].programPause(device));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async programResume(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].programResume(device));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async stop(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].stop(device));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async jogAngle(params, _pinsSettingsList, context) {
+        const { device, joint_id, direction, speed } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].jogAngle(device, joint_id, direction, speed));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async jogCoord(params, _pinsSettingsList, context) {
+        const { device, coord_id, direction, speed } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].jogCoord(device, coord_id, direction, speed));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async jogStop(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].jogStop(device));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setEncoder(params, _pinsSettingsList, context) {
+        const { device, joint_id, encoder } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setEncoder(device, joint_id, encoder));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setEncoders(params, _pinsSettingsList, context) {
+        const { device, encoders, speed } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setEncoders(device, encoders, speed));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setSpeed(params, _pinsSettingsList, context) {
+        const { device, speed } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setSpeed(device, speed));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setServoData(params, _pinsSettingsList, context) {
+        const { device, servo_no, data_id, value } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setServoData(device, servo_no, data_id, value));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setServoCalibration(params, _pinsSettingsList, context) {
+        const { device, servo_no } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setServoCalibration(device, servo_no));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async releaseServo(params, _pinsSettingsList, context) {
+        const { device, servo_no } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].releaseServo(device, servo_no));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async focusServo(params, _pinsSettingsList, context) {
+        const { device, servo_no } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].focusServo(device, servo_no));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setPinMode(params, _pinsSettingsList, context) {
+        const { device, pin_no, pin_mode } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setPinMode(device, pin_no, pin_mode));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setDigitalOutput(params, _pinsSettingsList, context) {
+        const { device, pin_no, pin_signal } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setDigitalOutput(device, pin_no, pin_signal));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setGripperState(params, _pinsSettingsList, context) {
+        const { device, flag, speed } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setGripperState(device, flag, speed));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setGripperValue(params, _pinsSettingsList, context) {
+        const { device, value, speed } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setGripperValue(device, value, speed));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setGripperIni(params, _pinsSettingsList, context) {
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setGripperIni());
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setBasicOutput(params, _pinsSettingsList, context) {
+        const { device, pin_no, pin_signal } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setBasicOutput(device, pin_no, pin_signal));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    async setColor(params, _pinsSettingsList, context) {
+        const { device, r, g, b } = params;
+        const connection = await this.connect(params, context);
+        const result = connection.write(mybuddy__default["default"].setColor(device, r, g, b));
+        await new Promise((resolve)=>setTimeout(resolve, 50));
+        connection.close();
+        return result;
+    }
+    // Data Retrieval
+    async getAngles(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async isPowerOn(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async isControllerConnect(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        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());
+        });
+    }
+    async getCoords(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async isInPosition(params, _pinsSettingsList, context) {
+        const { device, data, flag } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async getEncoder(params, _pinsSettingsList, context) {
+        const { device, joint_id } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async getEncoders(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async getSpeed(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async getJointMin(params, _pinsSettingsList, context) {
+        const { device, joint_id } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async getJointMax(params, _pinsSettingsList, context) {
+        const { device, joint_id } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async isServoEnable(params, _pinsSettingsList, context) {
+        const { device, servo_id } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async isAllServoEnable(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async getServodata(params, _pinsSettingsList, context) {
+        const { device, servo_no, data_id } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async getDigitalInput(params, _pinsSettingsList, context) {
+        const { device, pin_no } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async getGripperValue(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async getBasicOutput(params, _pinsSettingsList, context) {
+        const { device, pin_no } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    async isGripperMoving(params, _pinsSettingsList, context) {
+        const { device } = params;
+        const connection = await this.connect(params, context);
+        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));
+        });
+    }
+    // TOOLS
+    async sleep(params, _pinsSettingsList, context) {
+        const { time } = params;
+        await new Promise((resolve)=>setTimeout(resolve, time * 1000));
+        return context.previous;
+    }
+};
+const sendAngles = (params, pinsSettingsList, context)=>new MyBuddyService().sendAngles(params, pinsSettingsList, context);
+const getAngles = (params, pinsSettingsList, context)=>new MyBuddyService().getAngles(params, pinsSettingsList, context);
+// Add other export functions for actions and data retrieval methods
+const powerOn = (params, pinsSettingsList, context)=>new MyBuddyService().powerOn(params, pinsSettingsList, context);
+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);
+const stop = (params, pinsSettingsList, context)=>new MyBuddyService().stop(params, pinsSettingsList, context);
+const jogAngle = (params, pinsSettingsList, context)=>new MyBuddyService().jogAngle(params, pinsSettingsList, context);
+const jogCoord = (params, pinsSettingsList, context)=>new MyBuddyService().jogCoord(params, pinsSettingsList, context);
+const jogStop = (params, pinsSettingsList, context)=>new MyBuddyService().jogStop(params, pinsSettingsList, context);
+const setEncoder = (params, pinsSettingsList, context)=>new MyBuddyService().setEncoder(params, pinsSettingsList, context);
+const setEncoders = (params, pinsSettingsList, context)=>new MyBuddyService().setEncoders(params, pinsSettingsList, context);
+const setSpeed = (params, pinsSettingsList, context)=>new MyBuddyService().setSpeed(params, pinsSettingsList, context);
+const setServoData = (params, pinsSettingsList, context)=>new MyBuddyService().setServoData(params, pinsSettingsList, context);
+const setServoCalibration = (params, pinsSettingsList, context)=>new MyBuddyService().setServoCalibration(params, pinsSettingsList, context);
+const releaseServo = (params, pinsSettingsList, context)=>new MyBuddyService().releaseServo(params, pinsSettingsList, context);
+const focusServo = (params, pinsSettingsList, context)=>new MyBuddyService().focusServo(params, pinsSettingsList, context);
+const setPinMode = (params, pinsSettingsList, context)=>new MyBuddyService().setPinMode(params, pinsSettingsList, context);
+const setDigitalOutput = (params, pinsSettingsList, context)=>new MyBuddyService().setDigitalOutput(params, pinsSettingsList, context);
+const setGripperState = (params, pinsSettingsList, context)=>new MyBuddyService().setGripperState(params, pinsSettingsList, context);
+const setGripperValue = (params, pinsSettingsList, context)=>new MyBuddyService().setGripperValue(params, pinsSettingsList, context);
+const setGripperIni = (params, pinsSettingsList, context)=>new MyBuddyService().setGripperIni(params, pinsSettingsList, context);
+const setBasicOutput = (params, pinsSettingsList, context)=>new MyBuddyService().setBasicOutput(params, pinsSettingsList, context);
+const setColor = (params, pinsSettingsList, context)=>new MyBuddyService().setColor(params, pinsSettingsList, context);
+const isPowerOn = (params, pinsSettingsList, context)=>new MyBuddyService().isPowerOn(params, pinsSettingsList, context);
+const isControllerConnect = (params, pinsSettingsList, context)=>new MyBuddyService().isControllerConnect(params, pinsSettingsList, context);
+const getCoords = (params, pinsSettingsList, context)=>new MyBuddyService().getCoords(params, pinsSettingsList, context);
+const isInPosition = (params, pinsSettingsList, context)=>new MyBuddyService().isInPosition(params, pinsSettingsList, context);
+const getEncoder = (params, pinsSettingsList, context)=>new MyBuddyService().getEncoder(params, pinsSettingsList, context);
+const getEncoders = (params, pinsSettingsList, context)=>new MyBuddyService().getEncoders(params, pinsSettingsList, context);
+const getSpeed = (params, pinsSettingsList, context)=>new MyBuddyService().getSpeed(params, pinsSettingsList, context);
+const getJointMin = (params, pinsSettingsList, context)=>new MyBuddyService().getJointMin(params, pinsSettingsList, context);
+const getJointMax = (params, pinsSettingsList, context)=>new MyBuddyService().getJointMax(params, pinsSettingsList, context);
+const isServoEnable = (params, pinsSettingsList, context)=>new MyBuddyService().isServoEnable(params, pinsSettingsList, context);
+const isAllServoEnable = (params, pinsSettingsList, context)=>new MyBuddyService().isAllServoEnable(params, pinsSettingsList, context);
+const getServodata = (params, pinsSettingsList, context)=>new MyBuddyService().getServodata(params, pinsSettingsList, context);
+const getDigitalInput = (params, pinsSettingsList, context)=>new MyBuddyService().getDigitalInput(params, pinsSettingsList, context);
+const getGripperValue = (params, pinsSettingsList, context)=>new MyBuddyService().getGripperValue(params, pinsSettingsList, context);
+const getBasicOutput = (params, pinsSettingsList, context)=>new MyBuddyService().getBasicOutput(params, pinsSettingsList, context);
+const isGripperMoving = (params, pinsSettingsList, context)=>new MyBuddyService().isGripperMoving(params, pinsSettingsList, context);
+const sleep = (params, pinsSettingsList, context)=>new MyBuddyService().sleep(params, pinsSettingsList, context);
+
+exports.focusServo = focusServo;
+exports.getAngles = getAngles;
+exports.getBasicOutput = getBasicOutput;
+exports.getCoords = getCoords;
+exports.getDigitalInput = getDigitalInput;
+exports.getEncoder = getEncoder;
+exports.getEncoders = getEncoders;
+exports.getGripperValue = getGripperValue;
+exports.getJointMax = getJointMax;
+exports.getJointMin = getJointMin;
+exports.getServodata = getServodata;
+exports.getSpeed = getSpeed;
+exports.isAllServoEnable = isAllServoEnable;
+exports.isControllerConnect = isControllerConnect;
+exports.isGripperMoving = isGripperMoving;
+exports.isInPosition = isInPosition;
+exports.isPowerOn = isPowerOn;
+exports.isServoEnable = isServoEnable;
+exports.jogAngle = jogAngle;
+exports.jogCoord = jogCoord;
+exports.jogStop = jogStop;
+exports.powerOff = powerOff;
+exports.powerOn = powerOn;
+exports.programPause = programPause;
+exports.programResume = programResume;
+exports.releaseAllServos = releaseAllServos;
+exports.releaseServo = releaseServo;
+exports.sendAngle = sendAngle;
+exports.sendAngles = sendAngles;
+exports.sendCoord = sendCoord;
+exports.sendCoords = sendCoords;
+exports.setBasicOutput = setBasicOutput;
+exports.setColor = setColor;
+exports.setDigitalOutput = setDigitalOutput;
+exports.setEncoder = setEncoder;
+exports.setEncoders = setEncoders;
+exports.setGripperIni = setGripperIni;
+exports.setGripperState = setGripperState;
+exports.setGripperValue = setGripperValue;
+exports.setPinMode = setPinMode;
+exports.setServoCalibration = setServoCalibration;
+exports.setServoData = setServoData;
+exports.setSpeed = setSpeed;
+exports.sleep = sleep;
+exports.stop = stop;