@digipair/skill-mybuddy 0.23.9 → 0.23.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/index.cjs.js +248 -145
  2. package/index.esm.js +248 -145
  3. package/package.json +1 -1
  4. package/{libs/skill-mybuddy/src → src}/lib/skill-mybuddy.d.ts +17 -17
  5. /package/{libs/skill-mybuddy/src → src}/index.d.ts +0 -0
package/index.cjs.js CHANGED
@@ -8,6 +8,7 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
8
8
 
9
9
  var mybuddy__default = /*#__PURE__*/_interopDefaultLegacy(mybuddy);
10
10
 
11
+ const TIMEOUT_READ_COMMANDS = 1000;
11
12
  let MyBuddyService = class MyBuddyService {
12
13
  async connect(params, context) {
13
14
  var _context_privates_MY_BUDDY;
@@ -22,430 +23,532 @@ let MyBuddyService = class MyBuddyService {
22
23
  const { device, angles, speed = 50 } = params;
23
24
  const connection = await this.connect(params, context);
24
25
  const result = connection.write(mybuddy__default["default"].sendAngles(device, angles, speed));
25
- connection.close();
26
26
  await new Promise((resolve)=>setTimeout(resolve, 50));
27
+ connection.close();
27
28
  return result;
28
29
  }
29
30
  async powerOn(params, _pinsSettingsList, context) {
30
31
  const { device } = params;
31
32
  const connection = await this.connect(params, context);
32
33
  const result = connection.write(mybuddy__default["default"].powerOn(device));
33
- connection.close();
34
34
  await new Promise((resolve)=>setTimeout(resolve, 50));
35
+ connection.close();
35
36
  return result;
36
37
  }
37
38
  async powerOff(params, _pinsSettingsList, context) {
38
39
  const { device } = params;
39
40
  const connection = await this.connect(params, context);
40
41
  const result = connection.write(mybuddy__default["default"].powerOff(device));
41
- connection.close();
42
42
  await new Promise((resolve)=>setTimeout(resolve, 50));
43
+ connection.close();
43
44
  return result;
44
45
  }
45
46
  async releaseAllServos(params, _pinsSettingsList, context) {
46
47
  const { device } = params;
47
48
  const connection = await this.connect(params, context);
48
49
  const result = connection.write(mybuddy__default["default"].releaseAllServos(device));
49
- connection.close();
50
50
  await new Promise((resolve)=>setTimeout(resolve, 50));
51
+ connection.close();
51
52
  return result;
52
53
  }
53
54
  async sendAngle(params, _pinsSettingsList, context) {
54
55
  const { device, id = 1, degree = 0, speed = 60 } = params;
55
56
  const connection = await this.connect(params, context);
56
57
  const result = connection.write(mybuddy__default["default"].sendAngle(device, id, degree, speed));
57
- connection.close();
58
58
  await new Promise((resolve)=>setTimeout(resolve, 50));
59
+ connection.close();
59
60
  return result;
60
61
  }
61
62
  async sendCoords(params, _pinsSettingsList, context) {
62
63
  const { device, coords, speed, mode } = params;
63
64
  const connection = await this.connect(params, context);
64
65
  const result = connection.write(mybuddy__default["default"].sendCoords(device, coords, speed, mode));
65
- connection.close();
66
66
  await new Promise((resolve)=>setTimeout(resolve, 50));
67
+ connection.close();
67
68
  return result;
68
69
  }
69
70
  async programPause(params, _pinsSettingsList, context) {
70
71
  const { device } = params;
71
72
  const connection = await this.connect(params, context);
72
73
  const result = connection.write(mybuddy__default["default"].programPause(device));
73
- connection.close();
74
74
  await new Promise((resolve)=>setTimeout(resolve, 50));
75
+ connection.close();
75
76
  return result;
76
77
  }
77
78
  async programResume(params, _pinsSettingsList, context) {
78
79
  const { device } = params;
79
80
  const connection = await this.connect(params, context);
80
81
  const result = connection.write(mybuddy__default["default"].programResume(device));
81
- connection.close();
82
82
  await new Promise((resolve)=>setTimeout(resolve, 50));
83
+ connection.close();
83
84
  return result;
84
85
  }
85
86
  async stop(params, _pinsSettingsList, context) {
86
87
  const { device } = params;
87
88
  const connection = await this.connect(params, context);
88
89
  const result = connection.write(mybuddy__default["default"].stop(device));
89
- connection.close();
90
90
  await new Promise((resolve)=>setTimeout(resolve, 50));
91
+ connection.close();
91
92
  return result;
92
93
  }
93
94
  async jogAngle(params, _pinsSettingsList, context) {
94
95
  const { device, joint_id, direction, speed } = params;
95
96
  const connection = await this.connect(params, context);
96
97
  const result = connection.write(mybuddy__default["default"].jogAngle(device, joint_id, direction, speed));
97
- connection.close();
98
98
  await new Promise((resolve)=>setTimeout(resolve, 50));
99
+ connection.close();
99
100
  return result;
100
101
  }
101
102
  async jogCoord(params, _pinsSettingsList, context) {
102
103
  const { device, coord_id, direction, speed } = params;
103
104
  const connection = await this.connect(params, context);
104
105
  const result = connection.write(mybuddy__default["default"].jogCoord(device, coord_id, direction, speed));
105
- connection.close();
106
106
  await new Promise((resolve)=>setTimeout(resolve, 50));
107
+ connection.close();
107
108
  return result;
108
109
  }
109
110
  async jogStop(params, _pinsSettingsList, context) {
110
111
  const { device } = params;
111
112
  const connection = await this.connect(params, context);
112
113
  const result = connection.write(mybuddy__default["default"].jogStop(device));
113
- connection.close();
114
114
  await new Promise((resolve)=>setTimeout(resolve, 50));
115
+ connection.close();
115
116
  return result;
116
117
  }
117
118
  async setEncoder(params, _pinsSettingsList, context) {
118
119
  const { device, joint_id, encoder } = params;
119
120
  const connection = await this.connect(params, context);
120
121
  const result = connection.write(mybuddy__default["default"].setEncoder(device, joint_id, encoder));
121
- connection.close();
122
122
  await new Promise((resolve)=>setTimeout(resolve, 50));
123
+ connection.close();
123
124
  return result;
124
125
  }
125
126
  async setEncoders(params, _pinsSettingsList, context) {
126
127
  const { device, encoders, speed } = params;
127
128
  const connection = await this.connect(params, context);
128
129
  const result = connection.write(mybuddy__default["default"].setEncoders(device, encoders, speed));
129
- connection.close();
130
130
  await new Promise((resolve)=>setTimeout(resolve, 50));
131
+ connection.close();
131
132
  return result;
132
133
  }
133
134
  async setSpeed(params, _pinsSettingsList, context) {
134
135
  const { device, speed } = params;
135
136
  const connection = await this.connect(params, context);
136
137
  const result = connection.write(mybuddy__default["default"].setSpeed(device, speed));
137
- connection.close();
138
138
  await new Promise((resolve)=>setTimeout(resolve, 50));
139
+ connection.close();
139
140
  return result;
140
141
  }
141
142
  async setServoData(params, _pinsSettingsList, context) {
142
143
  const { device, servo_no, data_id, value } = params;
143
144
  const connection = await this.connect(params, context);
144
145
  const result = connection.write(mybuddy__default["default"].setServoData(device, servo_no, data_id, value));
145
- connection.close();
146
146
  await new Promise((resolve)=>setTimeout(resolve, 50));
147
+ connection.close();
147
148
  return result;
148
149
  }
149
150
  async setServoCalibration(params, _pinsSettingsList, context) {
150
151
  const { device, servo_no } = params;
151
152
  const connection = await this.connect(params, context);
152
153
  const result = connection.write(mybuddy__default["default"].setServoCalibration(device, servo_no));
153
- connection.close();
154
154
  await new Promise((resolve)=>setTimeout(resolve, 50));
155
+ connection.close();
155
156
  return result;
156
157
  }
157
158
  async releaseServo(params, _pinsSettingsList, context) {
158
159
  const { device, servo_no } = params;
159
160
  const connection = await this.connect(params, context);
160
161
  const result = connection.write(mybuddy__default["default"].releaseServo(device, servo_no));
161
- connection.close();
162
162
  await new Promise((resolve)=>setTimeout(resolve, 50));
163
+ connection.close();
163
164
  return result;
164
165
  }
165
166
  async focusServo(params, _pinsSettingsList, context) {
166
167
  const { device, servo_no } = params;
167
168
  const connection = await this.connect(params, context);
168
169
  const result = connection.write(mybuddy__default["default"].focusServo(device, servo_no));
169
- connection.close();
170
170
  await new Promise((resolve)=>setTimeout(resolve, 50));
171
+ connection.close();
171
172
  return result;
172
173
  }
173
174
  async setPinMode(params, _pinsSettingsList, context) {
174
175
  const { device, pin_no, pin_mode } = params;
175
176
  const connection = await this.connect(params, context);
176
177
  const result = connection.write(mybuddy__default["default"].setPinMode(device, pin_no, pin_mode));
177
- connection.close();
178
178
  await new Promise((resolve)=>setTimeout(resolve, 50));
179
+ connection.close();
179
180
  return result;
180
181
  }
181
182
  async setDigitalOutput(params, _pinsSettingsList, context) {
182
183
  const { device, pin_no, pin_signal } = params;
183
184
  const connection = await this.connect(params, context);
184
185
  const result = connection.write(mybuddy__default["default"].setDigitalOutput(device, pin_no, pin_signal));
185
- connection.close();
186
186
  await new Promise((resolve)=>setTimeout(resolve, 50));
187
+ connection.close();
187
188
  return result;
188
189
  }
189
190
  async setGripperState(params, _pinsSettingsList, context) {
190
191
  const { device, flag, speed } = params;
191
192
  const connection = await this.connect(params, context);
192
193
  const result = connection.write(mybuddy__default["default"].setGripperState(device, flag, speed));
193
- connection.close();
194
194
  await new Promise((resolve)=>setTimeout(resolve, 50));
195
+ connection.close();
195
196
  return result;
196
197
  }
197
198
  async setGripperValue(params, _pinsSettingsList, context) {
198
199
  const { device, value, speed } = params;
199
200
  const connection = await this.connect(params, context);
200
201
  const result = connection.write(mybuddy__default["default"].setGripperValue(device, value, speed));
201
- connection.close();
202
202
  await new Promise((resolve)=>setTimeout(resolve, 50));
203
+ connection.close();
203
204
  return result;
204
205
  }
205
206
  async setGripperIni(params, _pinsSettingsList, context) {
206
207
  const connection = await this.connect(params, context);
207
208
  const result = connection.write(mybuddy__default["default"].setGripperIni());
208
- connection.close();
209
209
  await new Promise((resolve)=>setTimeout(resolve, 50));
210
+ connection.close();
210
211
  return result;
211
212
  }
212
213
  async setBasicOutput(params, _pinsSettingsList, context) {
213
214
  const { device, pin_no, pin_signal } = params;
214
215
  const connection = await this.connect(params, context);
215
216
  const result = connection.write(mybuddy__default["default"].setBasicOutput(device, pin_no, pin_signal));
216
- connection.close();
217
217
  await new Promise((resolve)=>setTimeout(resolve, 50));
218
+ connection.close();
218
219
  return result;
219
220
  }
220
221
  async setColor(params, _pinsSettingsList, context) {
221
222
  const { device, r, g, b } = params;
222
223
  const connection = await this.connect(params, context);
223
224
  const result = connection.write(mybuddy__default["default"].setColor(device, r, g, b));
224
- connection.close();
225
225
  await new Promise((resolve)=>setTimeout(resolve, 50));
226
+ connection.close();
226
227
  return result;
227
228
  }
228
229
  // Data Retrieval
229
230
  async getAngles(params, _pinsSettingsList, context) {
230
231
  const { device } = params;
231
- let data = null;
232
232
  const connection = await this.connect(params, context);
233
- connection.on('data', (data)=>{
234
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ANGLES, 16)) {
235
- data = mybuddy__default["default"].processReceived(data);
233
+ return new Promise((resolve, reject)=>{
234
+ const timeoutId = setTimeout(()=>{
236
235
  connection.close();
237
- }
236
+ reject('TIMEOUT_READ_COMMANDS');
237
+ }, TIMEOUT_READ_COMMANDS);
238
+ connection.on('data', (data)=>{
239
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ANGLES, 16)) {
240
+ clearTimeout(timeoutId);
241
+ const result = mybuddy__default["default"].processReceived(data);
242
+ connection.close();
243
+ resolve(result);
244
+ }
245
+ });
246
+ connection.write(mybuddy__default["default"].getAngles(device));
238
247
  });
239
- connection.write(mybuddy__default["default"].getAngles(device));
240
- return data;
241
248
  }
242
249
  async isPowerOn(params, _pinsSettingsList, context) {
243
250
  const { device } = params;
244
- let data = null;
245
251
  const connection = await this.connect(params, context);
246
- connection.on('data', (data)=>{
247
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_POWER_ON, 16)) {
248
- data = mybuddy__default["default"].processReceived(data);
252
+ return new Promise((resolve, reject)=>{
253
+ const timeoutId = setTimeout(()=>{
249
254
  connection.close();
250
- }
255
+ reject('TIMEOUT_READ_COMMANDS');
256
+ }, TIMEOUT_READ_COMMANDS);
257
+ connection.on('data', (data)=>{
258
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_POWER_ON, 16)) {
259
+ clearTimeout(timeoutId);
260
+ const result = mybuddy__default["default"].processReceived(data);
261
+ connection.close();
262
+ resolve(result);
263
+ }
264
+ });
265
+ connection.write(mybuddy__default["default"].isPowerOn(device));
251
266
  });
252
- connection.write(mybuddy__default["default"].isPowerOn(device));
253
- return data;
254
267
  }
255
268
  async isControllerConnect(params, _pinsSettingsList, context) {
256
269
  const { device } = params;
257
- let data = null;
258
270
  const connection = await this.connect(params, context);
259
- connection.on('data', (data)=>{
260
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_CONTROLLER_CONNECTED, 16)) {
261
- data = mybuddy__default["default"].processReceived(data);
271
+ return new Promise((resolve, reject)=>{
272
+ const timeoutId = setTimeout(()=>{
262
273
  connection.close();
263
- }
274
+ reject('TIMEOUT_READ_COMMANDS');
275
+ }, TIMEOUT_READ_COMMANDS);
276
+ connection.on('data', (data)=>{
277
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_CONTROLLER_CONNECTED, 16)) {
278
+ clearTimeout(timeoutId);
279
+ const result = mybuddy__default["default"].processReceived(data);
280
+ connection.close();
281
+ resolve(result);
282
+ }
283
+ });
284
+ connection.write(mybuddy__default["default"].isControllerConnect());
264
285
  });
265
- connection.write(mybuddy__default["default"].isControllerConnect());
266
- return data;
267
286
  }
268
287
  async getCoords(params, _pinsSettingsList, context) {
269
288
  const { device } = params;
270
- let data = null;
271
289
  const connection = await this.connect(params, context);
272
- connection.on('data', (data)=>{
273
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_COORDS, 16)) {
274
- data = mybuddy__default["default"].processReceived(data);
290
+ return new Promise((resolve, reject)=>{
291
+ const timeoutId = setTimeout(()=>{
275
292
  connection.close();
276
- }
293
+ reject('TIMEOUT_READ_COMMANDS');
294
+ }, TIMEOUT_READ_COMMANDS);
295
+ connection.on('data', (data)=>{
296
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_COORDS, 16)) {
297
+ clearTimeout(timeoutId);
298
+ const result = mybuddy__default["default"].processReceived(data);
299
+ connection.close();
300
+ resolve(result);
301
+ }
302
+ });
303
+ connection.write(mybuddy__default["default"].getCoords(device));
277
304
  });
278
- connection.write(mybuddy__default["default"].getCoords(device));
279
- return data;
280
305
  }
281
306
  async isInPosition(params, _pinsSettingsList, context) {
282
307
  const { device, data, flag } = params;
283
- let result = null;
284
308
  const connection = await this.connect(params, context);
285
- connection.on('data', (data)=>{
286
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_IN_POSITION, 16)) {
287
- result = mybuddy__default["default"].processReceived(data);
309
+ return new Promise((resolve, reject)=>{
310
+ const timeoutId = setTimeout(()=>{
288
311
  connection.close();
289
- }
312
+ reject('TIMEOUT_READ_COMMANDS');
313
+ }, TIMEOUT_READ_COMMANDS);
314
+ connection.on('data', (data)=>{
315
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_IN_POSITION, 16)) {
316
+ clearTimeout(timeoutId);
317
+ const result = mybuddy__default["default"].processReceived(data);
318
+ connection.close();
319
+ resolve(result);
320
+ }
321
+ });
322
+ connection.write(mybuddy__default["default"].isInPosition(device, data, flag));
290
323
  });
291
- connection.write(mybuddy__default["default"].isInPosition(device, data, flag));
292
- return result;
293
324
  }
294
325
  async getEncoder(params, _pinsSettingsList, context) {
295
326
  const { device, joint_id } = params;
296
- let data = null;
297
327
  const connection = await this.connect(params, context);
298
- connection.on('data', (data)=>{
299
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ENCODER, 16)) {
300
- data = mybuddy__default["default"].processReceived(data);
328
+ return new Promise((resolve, reject)=>{
329
+ const timeoutId = setTimeout(()=>{
301
330
  connection.close();
302
- }
331
+ reject('TIMEOUT_READ_COMMANDS');
332
+ }, TIMEOUT_READ_COMMANDS);
333
+ connection.on('data', (data)=>{
334
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ENCODER, 16)) {
335
+ clearTimeout(timeoutId);
336
+ const result = mybuddy__default["default"].processReceived(data);
337
+ connection.close();
338
+ resolve(result);
339
+ }
340
+ });
341
+ connection.write(mybuddy__default["default"].getEncoder(device, joint_id));
303
342
  });
304
- connection.write(mybuddy__default["default"].getEncoder(device, joint_id));
305
- return data;
306
343
  }
307
344
  async getEncoders(params, _pinsSettingsList, context) {
308
345
  const { device } = params;
309
- let data = null;
310
346
  const connection = await this.connect(params, context);
311
- connection.on('data', (data)=>{
312
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ENCODER, 16)) {
313
- data = mybuddy__default["default"].processReceived(data);
347
+ return new Promise((resolve, reject)=>{
348
+ const timeoutId = setTimeout(()=>{
314
349
  connection.close();
315
- }
350
+ reject('TIMEOUT_READ_COMMANDS');
351
+ }, TIMEOUT_READ_COMMANDS);
352
+ connection.on('data', (data)=>{
353
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_ENCODER, 16)) {
354
+ clearTimeout(timeoutId);
355
+ const result = mybuddy__default["default"].processReceived(data);
356
+ connection.close();
357
+ resolve(result);
358
+ }
359
+ });
360
+ connection.write(mybuddy__default["default"].getEncoders(device));
316
361
  });
317
- connection.write(mybuddy__default["default"].getEncoders(device));
318
- return data;
319
362
  }
320
363
  async getSpeed(params, _pinsSettingsList, context) {
321
364
  const { device } = params;
322
- let data = null;
323
365
  const connection = await this.connect(params, context);
324
- connection.on('data', (data)=>{
325
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_SPEED, 16)) {
326
- data = mybuddy__default["default"].processReceived(data);
366
+ return new Promise((resolve, reject)=>{
367
+ const timeoutId = setTimeout(()=>{
327
368
  connection.close();
328
- }
369
+ reject('TIMEOUT_READ_COMMANDS');
370
+ }, TIMEOUT_READ_COMMANDS);
371
+ connection.on('data', (data)=>{
372
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_SPEED, 16)) {
373
+ clearTimeout(timeoutId);
374
+ const result = mybuddy__default["default"].processReceived(data);
375
+ connection.close();
376
+ resolve(result);
377
+ }
378
+ });
379
+ connection.write(mybuddy__default["default"].getSpeed(device));
329
380
  });
330
- connection.write(mybuddy__default["default"].getSpeed(device));
331
- return data;
332
381
  }
333
382
  async getJointMin(params, _pinsSettingsList, context) {
334
383
  const { device, joint_id } = params;
335
- let data = null;
336
384
  const connection = await this.connect(params, context);
337
- connection.on('data', (data)=>{
338
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_JOINT_MIN_ANGLE, 16)) {
339
- data = mybuddy__default["default"].processReceived(data);
385
+ return new Promise((resolve, reject)=>{
386
+ const timeoutId = setTimeout(()=>{
340
387
  connection.close();
341
- }
388
+ reject('TIMEOUT_READ_COMMANDS');
389
+ }, TIMEOUT_READ_COMMANDS);
390
+ connection.on('data', (data)=>{
391
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_JOINT_MIN_ANGLE, 16)) {
392
+ clearTimeout(timeoutId);
393
+ const result = mybuddy__default["default"].processReceived(data);
394
+ connection.close();
395
+ resolve(result);
396
+ }
397
+ });
398
+ connection.write(mybuddy__default["default"].getJointMin(device, joint_id));
342
399
  });
343
- connection.write(mybuddy__default["default"].getJointMin(device, joint_id));
344
- return data;
345
400
  }
346
401
  async getJointMax(params, _pinsSettingsList, context) {
347
402
  const { device, joint_id } = params;
348
- let data = null;
349
403
  const connection = await this.connect(params, context);
350
- connection.on('data', (data)=>{
351
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_JOINT_MAX_ANGLE, 16)) {
352
- data = mybuddy__default["default"].processReceived(data);
404
+ return new Promise((resolve, reject)=>{
405
+ const timeoutId = setTimeout(()=>{
353
406
  connection.close();
354
- }
407
+ reject('TIMEOUT_READ_COMMANDS');
408
+ }, TIMEOUT_READ_COMMANDS);
409
+ connection.on('data', (data)=>{
410
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_JOINT_MAX_ANGLE, 16)) {
411
+ clearTimeout(timeoutId);
412
+ const result = mybuddy__default["default"].processReceived(data);
413
+ connection.close();
414
+ resolve(result);
415
+ }
416
+ });
417
+ connection.write(mybuddy__default["default"].getJointMax(device, joint_id));
355
418
  });
356
- connection.write(mybuddy__default["default"].getJointMax(device, joint_id));
357
- return data;
358
419
  }
359
420
  async isServoEnable(params, _pinsSettingsList, context) {
360
421
  const { device, servo_id } = params;
361
- let data = null;
362
422
  const connection = await this.connect(params, context);
363
- connection.on('data', (data)=>{
364
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_SERVO_ENABLE, 16)) {
365
- data = mybuddy__default["default"].processReceived(data);
423
+ return new Promise((resolve, reject)=>{
424
+ const timeoutId = setTimeout(()=>{
366
425
  connection.close();
367
- }
426
+ reject('TIMEOUT_READ_COMMANDS');
427
+ }, TIMEOUT_READ_COMMANDS);
428
+ connection.on('data', (data)=>{
429
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_SERVO_ENABLE, 16)) {
430
+ clearTimeout(timeoutId);
431
+ const result = mybuddy__default["default"].processReceived(data);
432
+ connection.close();
433
+ resolve(result);
434
+ }
435
+ });
436
+ connection.write(mybuddy__default["default"].isServoEnable(device, servo_id));
368
437
  });
369
- connection.write(mybuddy__default["default"].isServoEnable(device, servo_id));
370
- return data;
371
438
  }
372
439
  async isAllServoEnable(params, _pinsSettingsList, context) {
373
440
  const { device } = params;
374
- let data = null;
375
441
  const connection = await this.connect(params, context);
376
- connection.on('data', (data)=>{
377
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_ALL_SERVO_ENABLE, 16)) {
378
- data = mybuddy__default["default"].processReceived(data);
442
+ return new Promise((resolve, reject)=>{
443
+ const timeoutId = setTimeout(()=>{
379
444
  connection.close();
380
- }
445
+ reject('TIMEOUT_READ_COMMANDS');
446
+ }, TIMEOUT_READ_COMMANDS);
447
+ connection.on('data', (data)=>{
448
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_ALL_SERVO_ENABLE, 16)) {
449
+ clearTimeout(timeoutId);
450
+ const result = mybuddy__default["default"].processReceived(data);
451
+ connection.close();
452
+ resolve(result);
453
+ }
454
+ });
455
+ connection.write(mybuddy__default["default"].isAllServoEnable(device));
381
456
  });
382
- connection.write(mybuddy__default["default"].isAllServoEnable(device));
383
- return data;
384
457
  }
385
458
  async getServodata(params, _pinsSettingsList, context) {
386
459
  const { device, servo_no, data_id } = params;
387
- let data = null;
388
460
  const connection = await this.connect(params, context);
389
- connection.on('data', (data)=>{
390
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_SERVO_DATA, 16)) {
391
- data = mybuddy__default["default"].processReceived(data);
461
+ return new Promise((resolve, reject)=>{
462
+ const timeoutId = setTimeout(()=>{
392
463
  connection.close();
393
- }
464
+ reject('TIMEOUT_READ_COMMANDS');
465
+ }, TIMEOUT_READ_COMMANDS);
466
+ connection.on('data', (data)=>{
467
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_SERVO_DATA, 16)) {
468
+ clearTimeout(timeoutId);
469
+ const result = mybuddy__default["default"].processReceived(data);
470
+ connection.close();
471
+ resolve(result);
472
+ }
473
+ });
474
+ connection.write(mybuddy__default["default"].getServodata(device, servo_no, data_id));
394
475
  });
395
- connection.write(mybuddy__default["default"].getServodata(device, servo_no, data_id));
396
- return data;
397
476
  }
398
477
  async getDigitalInput(params, _pinsSettingsList, context) {
399
478
  const { device, pin_no } = params;
400
- let data = null;
401
479
  const connection = await this.connect(params, context);
402
- connection.on('data', (data)=>{
403
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_DIGITAL_INPUT, 16)) {
404
- data = mybuddy__default["default"].processReceived(data);
480
+ return new Promise((resolve, reject)=>{
481
+ const timeoutId = setTimeout(()=>{
405
482
  connection.close();
406
- }
483
+ reject('TIMEOUT_READ_COMMANDS');
484
+ }, TIMEOUT_READ_COMMANDS);
485
+ connection.on('data', (data)=>{
486
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_DIGITAL_INPUT, 16)) {
487
+ clearTimeout(timeoutId);
488
+ const result = mybuddy__default["default"].processReceived(data);
489
+ connection.close();
490
+ resolve(result);
491
+ }
492
+ });
493
+ connection.write(mybuddy__default["default"].getDigitalInput(device, pin_no));
407
494
  });
408
- connection.write(mybuddy__default["default"].getDigitalInput(device, pin_no));
409
- return data;
410
495
  }
411
496
  async getGripperValue(params, _pinsSettingsList, context) {
412
497
  const { device } = params;
413
- let data = null;
414
498
  const connection = await this.connect(params, context);
415
- connection.on('data', (data)=>{
416
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_GRIPPER_VALUE, 16)) {
417
- data = mybuddy__default["default"].processReceived(data);
499
+ return new Promise((resolve, reject)=>{
500
+ const timeoutId = setTimeout(()=>{
418
501
  connection.close();
419
- }
502
+ reject('TIMEOUT_READ_COMMANDS');
503
+ }, TIMEOUT_READ_COMMANDS);
504
+ connection.on('data', (data)=>{
505
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_GRIPPER_VALUE, 16)) {
506
+ clearTimeout(timeoutId);
507
+ const result = mybuddy__default["default"].processReceived(data);
508
+ connection.close();
509
+ resolve(result);
510
+ }
511
+ });
512
+ connection.write(mybuddy__default["default"].getGripperValue(device));
420
513
  });
421
- connection.write(mybuddy__default["default"].getGripperValue(device));
422
- return data;
423
514
  }
424
515
  async getBasicOutput(params, _pinsSettingsList, context) {
425
516
  const { device, pin_no } = params;
426
- let data = null;
427
517
  const connection = await this.connect(params, context);
428
- connection.on('data', (data)=>{
429
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_BASIC_INPUT, 16)) {
430
- data = mybuddy__default["default"].processReceived(data);
518
+ return new Promise((resolve, reject)=>{
519
+ const timeoutId = setTimeout(()=>{
431
520
  connection.close();
432
- }
521
+ reject('TIMEOUT_READ_COMMANDS');
522
+ }, TIMEOUT_READ_COMMANDS);
523
+ connection.on('data', (data)=>{
524
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.GET_BASIC_INPUT, 16)) {
525
+ clearTimeout(timeoutId);
526
+ const result = mybuddy__default["default"].processReceived(data);
527
+ connection.close();
528
+ resolve(result);
529
+ }
530
+ });
531
+ connection.write(mybuddy__default["default"].getBasicOutput(device, pin_no));
433
532
  });
434
- connection.write(mybuddy__default["default"].getBasicOutput(device, pin_no));
435
- return data;
436
533
  }
437
534
  async isGripperMoving(params, _pinsSettingsList, context) {
438
535
  const { device } = params;
439
- let data = null;
440
536
  const connection = await this.connect(params, context);
441
- connection.on('data', (data)=>{
442
- if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_GRIPPER_MOVING, 16)) {
443
- data = mybuddy__default["default"].processReceived(data);
537
+ return new Promise((resolve, reject)=>{
538
+ const timeoutId = setTimeout(()=>{
444
539
  connection.close();
445
- }
540
+ reject('TIMEOUT_READ_COMMANDS');
541
+ }, TIMEOUT_READ_COMMANDS);
542
+ connection.on('data', (data)=>{
543
+ if (data[0] === 0xfe && data[1] === 0xfe && data[2] === device && data[4] === parseInt(mybuddy__default["default"].COMMAND.IS_GRIPPER_MOVING, 16)) {
544
+ clearTimeout(timeoutId);
545
+ const result = mybuddy__default["default"].processReceived(data);
546
+ connection.close();
547
+ resolve(result);
548
+ }
549
+ });
550
+ connection.write(mybuddy__default["default"].isGripperMoving(device));
446
551
  });
447
- connection.write(mybuddy__default["default"].isGripperMoving(device));
448
- return data;
449
552
  }
450
553
  // TOOLS
451
554
  async sleep(params, _pinsSettingsList, context) {