bcap_service.cpp
Go to the documentation of this file.
1 
25 #include <stdlib.h>
26 #include <sstream>
27 #include "bcap_service/bcap_service.h"
28 #include "bcap_core/bcap_funcid.h"
29 #include "bcap_core/bCAPClient/bcap_client.h"
30 #include "bcap_core/RACString/rac_string.h"
31 
32 int main(int argc, char** argv)
33 {
34  ros::init(argc, argv, "bcap_service");
35 
36  HRESULT hr;
37  ros::NodeHandle node;
38 
39  bcap_service::BCAPService bcapsrv;
40 
41  bcapsrv.parseParams();
42 
43  hr = bcapsrv.Connect();
44  if(FAILED(hr)) {
45  ROS_ERROR("Failed to connect. (%X)", hr);
46  return 1;
47  } else {
48  bcapsrv.StartService(node);
49 
50  ros::spin();
51 
52  bcapsrv.StopService();
53  bcapsrv.Disconnect();
54  return 0;
55  }
56 }
57 
58 namespace bcap_service {
59 
60 BCAPService::BCAPService()
61  : m_type(""), m_addr(""),
62  m_port(0), m_timeout(0), m_retry(0), m_wait(0),
63  m_fd(0), m_wdt(0), m_invoke(0)
64 {
65 
66 }
67 
68 BCAPService::~BCAPService()
69 {
70  StopService();
71  Disconnect();
72 }
73 
74 void BCAPService::parseParams()
75 {
76  ros::NodeHandle node;
77 
78  if(!node.getParam("conn_type", m_type))
79  {
80  m_type = "tcp";
81  }
82 
83  if(!node.getParam("ip_address", m_addr))
84  {
85  m_addr = "192.168.0.1";
86  }
87 
88  if(!node.getParam("port_number", m_port))
89  {
90  m_port = 5007;
91  }
92 
93  if(!node.getParam("timeout", m_timeout))
94  {
95  m_timeout = 3000;
96  }
97 
98  if(!node.getParam("retry_count", m_retry))
99  {
100  m_retry = 5;
101  }
102 
103  if(!node.getParam("wait_time", m_wait))
104  {
105  m_wait = 0;
106  }
107 
108  if(!node.getParam("watchdog_timer", m_wdt))
109  {
110  m_wdt = 400;
111  }
112 
113  if(!node.getParam("invoke_timeout", m_invoke))
114  {
115  m_invoke = 180000;
116  }
117 }
118 
119 HRESULT BCAPService::Connect()
120 {
121  HRESULT hr;
122  std::stringstream ss1;
123  std::wstringstream ss2;
124 
125  ros::Duration(m_wait).sleep();
126 
127  ss1 << m_type << ":" << m_addr << ":" << m_port;
128  hr = bCap_Open_Client(ss1.str().c_str(), m_timeout, m_retry, &m_fd);
129  if(SUCCEEDED(hr)) {
130  ss2 << L",WDT=" << m_wdt << L",InvokeTimeout=" << m_invoke;
131  BSTR bstrOption = SysAllocString(ss2.str().c_str());
132  hr = bCap_ServiceStart(m_fd, bstrOption);
133  SysFreeString(bstrOption);
134  }
135 
136  return hr;
137 }
138 
139 HRESULT BCAPService::Disconnect()
140 {
141  if(m_fd > 0) {
142  KeyHandle_Vec::iterator it;
143  for(it = m_vecKH.begin(); it != m_vecKH.end(); it++) {
144  switch(it->first){
145  case ID_CONTROLLER_DISCONNECT:
146  bCap_ControllerDisconnect(m_fd, &it->second);
147  break;
148  case ID_EXTENSION_RELEASE:
149  bCap_ExtensionRelease(m_fd, &it->second);
150  break;
151  case ID_FILE_RELEASE:
152  bCap_FileRelease(m_fd, &it->second);
153  break;
154  case ID_ROBOT_RELEASE:
155  bCap_RobotRelease(m_fd, &it->second);
156  break;
157  case ID_TASK_RELEASE:
158  bCap_TaskRelease(m_fd, &it->second);
159  break;
160  case ID_VARIABLE_RELEASE:
161  bCap_VariableRelease(m_fd, &it->second);
162  break;
163  case ID_COMMAND_RELEASE:
164  bCap_CommandRelease(m_fd, &it->second);
165  break;
166  case ID_MESSAGE_RELEASE:
167  bCap_MessageRelease(m_fd, &it->second);
168  break;
169  }
170  }
171 
172  m_vecKH.clear();
173 
174  bCap_ServiceStop(m_fd);
175 
176  bCap_Close_Client(&m_fd);
177  }
178 
179  return S_OK;
180 }
181 
182 HRESULT BCAPService::StartService(ros::NodeHandle& node)
183 {
184  m_svr = node.advertiseService("bcap_service", &BCAPService::CallFunction, this);
185  return S_OK;
186 }
187 
188 HRESULT BCAPService::StopService()
189 {
190  m_svr.shutdown();
191  return S_OK;
192 }
193 
194 const std::string& BCAPService::get_Type() const
195 {
196  return m_type;
197 }
198 
199 void BCAPService::put_Type(const std::string& type)
200 {
201  if(m_fd == 0) {
202  m_type = type;
203  }
204 }
205 
206 uint32_t BCAPService::get_Timeout() const
207 {
208  uint32_t value = 0;
209  if(FAILED(bCap_GetTimeout(m_fd, &value))) {
210  value = m_timeout;
211  }
212  return value;
213 }
214 
215 void BCAPService::put_Timeout(uint32_t value)
216 {
217  if(SUCCEEDED(bCap_SetTimeout(m_fd, value))) {
218  m_timeout = value;
219  }
220 }
221 
222 unsigned int BCAPService::get_Retry() const
223 {
224  unsigned int value = 0;
225  if(FAILED(bCap_GetRetry(m_fd, &value))) {
226  value = m_retry;
227  }
228  return value;
229 }
230 
231 void BCAPService::put_Retry(unsigned int value)
232 {
233  if(SUCCEEDED(bCap_SetRetry(m_fd, value))) {
234  m_retry = value;
235  }
236 }
237 
238 bool BCAPService::CallFunction(bcap::Request &req, bcap::Response &res)
239 {
240  HRESULT hr = S_OK;
241  char *chRet = NULL;
242  VARIANT_Vec vntArgs;
243  VARIANT_Ptr vntRet(new VARIANT());
244  VariantInit(vntRet.get());
245 
246  for(int i = 0; i < req.vntArgs.size(); i++) {
247  VARIANT_Ptr vntTmp(new VARIANT());
248  VariantInit(vntTmp.get());
249  hr = ConvertRacStr2Variant(
250  req.vntArgs[i].vt, req.vntArgs[i].value.c_str(),
251  vntTmp.get());
252  if(FAILED(hr)) goto err_proc;
253  vntArgs.push_back(*vntTmp.get());
254  }
255 
256  hr = ExecFunction(req.func_id, vntArgs, vntRet);
257  if(FAILED(hr)) goto err_proc;
258 
259  hr = ConvertVariant2RacStr(*vntRet.get(), &chRet);
260  if(FAILED(hr)) goto err_proc;
261 
262  res.HRESULT = S_OK;
263  res.vntRet.vt = vntRet->vt;
264  res.vntRet.value = chRet;
265 
266  free(chRet);
267 
268 post_proc:
269  return true;
270 
271 err_proc:
272  res.HRESULT = hr;
273  res.vntRet.vt = VT_EMPTY;
274  res.vntRet.value = "";
275 
276  goto post_proc;
277 }
278 
279 HRESULT BCAPService::ExecFunction(
280  int32_t func_id, VARIANT_Vec& vntArgs,
281  VARIANT_Ptr& vntRet)
282 {
283  HRESULT hr = E_INVALIDARG;
284  KeyHandle tmpKH(0, 0);
285 
286  try {
287  switch(func_id) {
288  // Controller
289  case ID_CONTROLLER_CONNECT:
290  vntRet->vt = VT_UI4;
291  hr = bCap_ControllerConnect(m_fd,
292  vntArgs.at(0).bstrVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal, vntArgs.at(3).bstrVal,
293  &vntRet->ulVal);
294  tmpKH.first = ID_CONTROLLER_DISCONNECT;
295  break;
296  case ID_CONTROLLER_DISCONNECT:
297  tmpKH.second = vntArgs.at(0).ulVal;
298  hr = bCap_ControllerDisconnect(m_fd,
299  &vntArgs.at(0).ulVal);
300  break;
301  case ID_CONTROLLER_GETEXTENSION:
302  vntRet->vt = VT_UI4;
303  hr = bCap_ControllerGetExtension(m_fd,
304  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal,
305  &vntRet->ulVal);
306  tmpKH.first = ID_EXTENSION_RELEASE;
307  break;
308  case ID_CONTROLLER_GETFILE:
309  vntRet->vt = VT_UI4;
310  hr = bCap_ControllerGetFile(m_fd,
311  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal,
312  &vntRet->ulVal);
313  tmpKH.first = ID_FILE_RELEASE;
314  break;
315  case ID_CONTROLLER_GETROBOT:
316  vntRet->vt = VT_UI4;
317  hr = bCap_ControllerGetRobot(m_fd,
318  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal,
319  &vntRet->ulVal);
320  tmpKH.first = ID_ROBOT_RELEASE;
321  break;
322  case ID_CONTROLLER_GETTASK:
323  vntRet->vt = VT_UI4;
324  hr = bCap_ControllerGetTask(m_fd,
325  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal,
326  &vntRet->ulVal);
327  tmpKH.first = ID_TASK_RELEASE;
328  break;
329  case ID_CONTROLLER_GETVARIABLE:
330  vntRet->vt = VT_UI4;
331  hr = bCap_ControllerGetVariable(m_fd,
332  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal,
333  &vntRet->ulVal);
334  tmpKH.first = ID_VARIABLE_RELEASE;
335  break;
336  case ID_CONTROLLER_GETCOMMAND:
337  vntRet->vt = VT_UI4;
338  hr = bCap_ControllerGetCommand(m_fd,
339  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal,
340  &vntRet->ulVal);
341  tmpKH.first = ID_COMMAND_RELEASE;
342  break;
343  case ID_CONTROLLER_GETEXTENSIONNAMES:
344  hr = bCap_ControllerGetExtensionNames(m_fd,
345  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
346  vntRet.get());
347  break;
348  case ID_CONTROLLER_GETFILENAMES:
349  hr = bCap_ControllerGetFileNames(m_fd,
350  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
351  vntRet.get());
352  break;
353  case ID_CONTROLLER_GETROBOTNAMES:
354  hr = bCap_ControllerGetRobotNames(m_fd,
355  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
356  vntRet.get());
357  break;
358  case ID_CONTROLLER_GETTASKNAMES:
359  hr = bCap_ControllerGetTaskNames(m_fd,
360  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
361  vntRet.get());
362  break;
363  case ID_CONTROLLER_GETVARIABLENAMES:
364  hr = bCap_ControllerGetVariableNames(m_fd,
365  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
366  vntRet.get());
367  break;
368  case ID_CONTROLLER_GETCOMMANDNAMES:
369  hr = bCap_ControllerGetCommandNames(m_fd,
370  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
371  vntRet.get());
372  break;
373  case ID_CONTROLLER_EXECUTE:
374  hr = bCap_ControllerExecute(m_fd,
375  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2),
376  vntRet.get());
377  break;
378  case ID_CONTROLLER_GETMESSAGE:
379  vntRet->vt = VT_UI4;
380  hr = bCap_ControllerGetMessage(m_fd,
381  vntArgs.at(0).ulVal,
382  &vntRet->ulVal);
383  tmpKH.first = ID_MESSAGE_RELEASE;
384  break;
385  case ID_CONTROLLER_GETATTRIBUTE:
386  vntRet->vt = VT_I4;
387  hr = bCap_ControllerGetAttribute(m_fd,
388  vntArgs.at(0).ulVal,
389  &vntRet->lVal);
390  break;
391  case ID_CONTROLLER_GETHELP:
392  vntRet->vt = VT_BSTR;
393  hr = bCap_ControllerGetHelp(m_fd,
394  vntArgs.at(0).ulVal,
395  &vntRet->bstrVal);
396  break;
397  case ID_CONTROLLER_GETNAME:
398  vntRet->vt = VT_BSTR;
399  hr = bCap_ControllerGetName(m_fd,
400  vntArgs.at(0).ulVal,
401  &vntRet->bstrVal);
402  break;
403  case ID_CONTROLLER_GETTAG:
404  hr = bCap_ControllerGetTag(m_fd,
405  vntArgs.at(0).ulVal,
406  vntRet.get());
407  break;
408  case ID_CONTROLLER_PUTTAG:
409  hr = bCap_ControllerPutTag(m_fd,
410  vntArgs.at(0).ulVal, vntArgs.at(1));
411  break;
412  case ID_CONTROLLER_GETID:
413  hr = bCap_ControllerGetID(m_fd,
414  vntArgs.at(0).ulVal,
415  vntRet.get());
416  break;
417  case ID_CONTROLLER_PUTID:
418  hr = bCap_ControllerPutID(m_fd,
419  vntArgs.at(0).ulVal, vntArgs.at(1));
420  break;
421  // Extension
422  case ID_EXTENSION_GETVARIABLE:
423  vntRet->vt = VT_UI4;
424  hr = bCap_ExtensionGetVariable(m_fd,
425  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal,
426  &vntRet->ulVal);
427  tmpKH.first = ID_VARIABLE_RELEASE;
428  break;
429  case ID_EXTENSION_GETVARIABLENAMES:
430  hr = bCap_ExtensionGetVariableNames(m_fd,
431  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
432  vntRet.get());
433  break;
434  case ID_EXTENSION_EXECUTE:
435  hr = bCap_ExtensionExecute(m_fd,
436  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2),
437  vntRet.get());
438  break;
439  case ID_EXTENSION_GETATTRIBUTE:
440  vntRet->vt = VT_I4;
441  hr = bCap_ExtensionGetAttribute(m_fd,
442  vntArgs.at(0).ulVal,
443  &vntRet->lVal);
444  break;
445  case ID_EXTENSION_GETHELP:
446  vntRet->vt = VT_BSTR;
447  hr = bCap_ExtensionGetHelp(m_fd,
448  vntArgs.at(0).ulVal,
449  &vntRet->bstrVal);
450  break;
451  case ID_EXTENSION_GETNAME:
452  vntRet->vt = VT_BSTR;
453  hr = bCap_ExtensionGetName(m_fd,
454  vntArgs.at(0).ulVal,
455  &vntRet->bstrVal);
456  break;
457  case ID_EXTENSION_GETTAG:
458  hr = bCap_ExtensionGetTag(m_fd,
459  vntArgs.at(0).ulVal,
460  vntRet.get());
461  break;
462  case ID_EXTENSION_PUTTAG:
463  hr = bCap_ExtensionPutTag(m_fd,
464  vntArgs.at(0).ulVal, vntArgs.at(1));
465  break;
466  case ID_EXTENSION_GETID:
467  hr = bCap_ExtensionGetID(m_fd,
468  vntArgs.at(0).ulVal,
469  vntRet.get());
470  break;
471  case ID_EXTENSION_PUTID:
472  hr = bCap_ExtensionPutID(m_fd,
473  vntArgs.at(0).ulVal, vntArgs.at(1));
474  break;
475  case ID_EXTENSION_RELEASE:
476  tmpKH.second = vntArgs.at(0).ulVal;
477  hr = bCap_ExtensionRelease(m_fd,
478  &vntArgs.at(0).ulVal);
479  break;
480  // File
481  case ID_FILE_GETFILE:
482  vntRet->vt = VT_UI4;
483  hr = bCap_FileGetFile(m_fd,
484  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal,
485  &vntRet->ulVal);
486  tmpKH.first = ID_FILE_RELEASE;
487  break;
488  case ID_FILE_GETVARIABLE:
489  vntRet->vt = VT_UI4;
490  hr = bCap_FileGetVariable(m_fd,
491  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal,
492  &vntRet->ulVal);
493  tmpKH.first = ID_VARIABLE_RELEASE;
494  break;
495  case ID_FILE_GETFILENAMES:
496  hr = bCap_FileGetFileNames(m_fd,
497  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
498  vntRet.get());
499  break;
500  case ID_FILE_GETVARIABLENAMES:
501  hr = bCap_FileGetVariableNames(m_fd,
502  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
503  vntRet.get());
504  break;
505  case ID_FILE_EXECUTE:
506  hr = bCap_FileExecute(m_fd,
507  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2),
508  vntRet.get());
509  break;
510  case ID_FILE_COPY:
511  hr = bCap_FileCopy(m_fd,
512  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal);
513  break;
514  case ID_FILE_DELETE:
515  hr = bCap_FileDelete(m_fd,
516  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal);
517  break;
518  case ID_FILE_MOVE:
519  hr = bCap_FileMove(m_fd,
520  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal);
521  break;
522  case ID_FILE_RUN:
523  vntRet->vt = VT_BSTR;
524  hr = bCap_FileRun(m_fd,
525  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
526  &vntRet->bstrVal);
527  break;
528  case ID_FILE_GETDATECREATED:
529  hr = bCap_FileGetDateCreated(m_fd,
530  vntArgs.at(0).ulVal,
531  vntRet.get());
532  break;
533  case ID_FILE_GETDATELASTACCESSED:
534  hr = bCap_FileGetDateLastAccessed(m_fd,
535  vntArgs.at(0).ulVal,
536  vntRet.get());
537  break;
538  case ID_FILE_GETDATELASTMODIFIED:
539  hr = bCap_FileGetDateLastModified(m_fd,
540  vntArgs.at(0).ulVal,
541  vntRet.get());
542  break;
543  case ID_FILE_GETPATH:
544  vntRet->vt = VT_BSTR;
545  hr = bCap_FileGetPath(m_fd,
546  vntArgs.at(0).ulVal,
547  &vntRet->bstrVal);
548  break;
549  case ID_FILE_GETSIZE:
550  vntRet->vt = VT_I4;
551  hr = bCap_FileGetSize(m_fd,
552  vntArgs.at(0).ulVal,
553  &vntRet->lVal);
554  break;
555  case ID_FILE_GETTYPE:
556  vntRet->vt = VT_BSTR;
557  hr = bCap_FileGetType(m_fd,
558  vntArgs.at(0).ulVal,
559  &vntRet->bstrVal);
560  break;
561  case ID_FILE_GETVALUE:
562  hr = bCap_FileGetValue(m_fd,
563  vntArgs.at(0).ulVal,
564  vntRet.get());
565  break;
566  case ID_FILE_PUTVALUE:
567  hr = bCap_FilePutValue(m_fd,
568  vntArgs.at(0).ulVal, vntArgs.at(1));
569  break;
570  case ID_FILE_GETATTRIBUTE:
571  vntRet->vt = VT_I4;
572  hr = bCap_FileGetAttribute(m_fd,
573  vntArgs.at(0).ulVal,
574  &vntRet->lVal);
575  break;
576  case ID_FILE_GETHELP:
577  vntRet->vt = VT_BSTR;
578  hr = bCap_FileGetHelp(m_fd,
579  vntArgs.at(0).ulVal,
580  &vntRet->bstrVal);
581  break;
582  case ID_FILE_GETNAME:
583  vntRet->vt = VT_BSTR;
584  hr = bCap_FileGetName(m_fd,
585  vntArgs.at(0).ulVal,
586  &vntRet->bstrVal);
587  break;
588  case ID_FILE_GETTAG:
589  hr = bCap_FileGetTag(m_fd,
590  vntArgs.at(0).ulVal,
591  vntRet.get());
592  break;
593  case ID_FILE_PUTTAG:
594  hr = bCap_FilePutTag(m_fd,
595  vntArgs.at(0).ulVal, vntArgs.at(1));
596  break;
597  case ID_FILE_GETID:
598  hr = bCap_FileGetID(m_fd,
599  vntArgs.at(0).ulVal,
600  vntRet.get());
601  break;
602  case ID_FILE_PUTID:
603  hr = bCap_FilePutID(m_fd,
604  vntArgs.at(0).ulVal, vntArgs.at(1));
605  break;
606  case ID_FILE_RELEASE:
607  tmpKH.second = vntArgs.at(0).ulVal;
608  hr = bCap_FileRelease(m_fd,
609  &vntArgs.at(0).ulVal);
610  break;
611  // Robot
612  case ID_ROBOT_GETVARIABLE:
613  vntRet->vt = VT_UI4;
614  hr = bCap_RobotGetVariable(m_fd,
615  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal,
616  &vntRet->ulVal);
617  tmpKH.first = ID_VARIABLE_RELEASE;
618  break;
619  case ID_ROBOT_GETVARIABLENAMES:
620  hr = bCap_RobotGetVariableNames(m_fd,
621  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
622  vntRet.get());
623  break;
624  case ID_ROBOT_EXECUTE:
625  hr = bCap_RobotExecute(m_fd,
626  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2),
627  vntRet.get());
628  break;
629  case ID_ROBOT_ACCELERATE:
630  hr = bCap_RobotAccelerate(m_fd,
631  vntArgs.at(0).ulVal, vntArgs.at(1).lVal, vntArgs.at(2).fltVal, vntArgs.at(3).fltVal);
632  break;
633  case ID_ROBOT_CHANGE:
634  hr = bCap_RobotChange(m_fd,
635  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal);
636  break;
637  case ID_ROBOT_CHUCK:
638  hr = bCap_RobotChuck(m_fd,
639  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal);
640  break;
641  case ID_ROBOT_DRIVE:
642  hr = bCap_RobotDrive(m_fd,
643  vntArgs.at(0).ulVal, vntArgs.at(1).lVal, vntArgs.at(2).fltVal, vntArgs.at(3).bstrVal);
644  break;
645  case ID_ROBOT_GOHOME:
646  hr = bCap_RobotGoHome(m_fd,
647  vntArgs.at(0).ulVal);
648  break;
649  case ID_ROBOT_HALT:
650  hr = bCap_RobotHalt(m_fd,
651  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal);
652  break;
653  case ID_ROBOT_HOLD:
654  hr = bCap_RobotHold(m_fd,
655  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal);
656  break;
657  case ID_ROBOT_MOVE:
658  hr = bCap_RobotMove(m_fd,
659  vntArgs.at(0).ulVal, vntArgs.at(1).lVal, vntArgs.at(2), vntArgs.at(3).bstrVal);
660  break;
661  case ID_ROBOT_ROTATE:
662  hr = bCap_RobotRotate(m_fd,
663  vntArgs.at(0).ulVal, vntArgs.at(1), vntArgs.at(2).fltVal, vntArgs.at(3), vntArgs.at(4).bstrVal);
664  break;
665  case ID_ROBOT_SPEED:
666  hr = bCap_RobotSpeed(m_fd,
667  vntArgs.at(0).ulVal, vntArgs.at(1).lVal, vntArgs.at(2).fltVal);
668  break;
669  case ID_ROBOT_UNCHUCK:
670  hr = bCap_RobotUnchuck(m_fd,
671  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal);
672  break;
673  case ID_ROBOT_UNHOLD:
674  hr = bCap_RobotUnhold(m_fd,
675  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal);
676  break;
677  case ID_ROBOT_GETATTRIBUTE:
678  vntRet->vt = VT_I4;
679  hr = bCap_RobotGetAttribute(m_fd,
680  vntArgs.at(0).ulVal,
681  &vntRet->lVal);
682  break;
683  case ID_ROBOT_GETHELP:
684  vntRet->vt = VT_BSTR;
685  hr = bCap_RobotGetHelp(m_fd,
686  vntArgs.at(0).ulVal,
687  &vntRet->bstrVal);
688  break;
689  case ID_ROBOT_GETNAME:
690  vntRet->vt = VT_BSTR;
691  hr = bCap_RobotGetName(m_fd,
692  vntArgs.at(0).ulVal,
693  &vntRet->bstrVal);
694  break;
695  case ID_ROBOT_GETTAG:
696  hr = bCap_RobotGetTag(m_fd,
697  vntArgs.at(0).ulVal,
698  vntRet.get());
699  break;
700  case ID_ROBOT_PUTTAG:
701  hr = bCap_RobotPutTag(m_fd,
702  vntArgs.at(0).ulVal, vntArgs.at(1));
703  break;
704  case ID_ROBOT_GETID:
705  hr = bCap_RobotGetID(m_fd,
706  vntArgs.at(0).ulVal,
707  vntRet.get());
708  break;
709  case ID_ROBOT_PUTID:
710  hr = bCap_RobotPutID(m_fd,
711  vntArgs.at(0).ulVal, vntArgs.at(1));
712  break;
713  case ID_ROBOT_RELEASE:
714  tmpKH.second = vntArgs.at(0).ulVal;
715  hr = bCap_RobotRelease(m_fd,
716  &vntArgs.at(0).ulVal);
717  break;
718  // Task
719  case ID_TASK_GETVARIABLE:
720  vntRet->vt = VT_UI4;
721  hr = bCap_TaskGetVariable(m_fd,
722  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2).bstrVal,
723  &vntRet->ulVal);
724  tmpKH.first = ID_VARIABLE_RELEASE;
725  break;
726  case ID_TASK_GETVARIABLENAMES:
727  hr = bCap_TaskGetVariableNames(m_fd,
728  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal,
729  vntRet.get());
730  break;
731  case ID_TASK_EXECUTE:
732  hr = bCap_TaskExecute(m_fd,
733  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal, vntArgs.at(2),
734  vntRet.get());
735  break;
736  case ID_TASK_START:
737  hr = bCap_TaskStart(m_fd,
738  vntArgs.at(0).ulVal, vntArgs.at(1).lVal, vntArgs.at(2).bstrVal);
739  break;
740  case ID_TASK_STOP:
741  hr = bCap_TaskStop(m_fd,
742  vntArgs.at(0).ulVal, vntArgs.at(1).lVal, vntArgs.at(2).bstrVal);
743  break;
744  case ID_TASK_DELETE:
745  hr = bCap_TaskDelete(m_fd,
746  vntArgs.at(0).ulVal, vntArgs.at(1).bstrVal);
747  break;
748  case ID_TASK_GETFILENAME:
749  vntRet->vt = VT_BSTR;
750  hr = bCap_TaskGetFileName(m_fd,
751  vntArgs.at(0).ulVal,
752  &vntRet->bstrVal);
753  break;
754  case ID_TASK_GETATTRIBUTE:
755  vntRet->vt = VT_I4;
756  hr = bCap_TaskGetAttribute(m_fd,
757  vntArgs.at(0).ulVal,
758  &vntRet->lVal);
759  break;
760  case ID_TASK_GETHELP:
761  vntRet->vt = VT_BSTR;
762  hr = bCap_TaskGetHelp(m_fd,
763  vntArgs.at(0).ulVal,
764  &vntRet->bstrVal);
765  break;
766  case ID_TASK_GETNAME:
767  vntRet->vt = VT_BSTR;
768  hr = bCap_TaskGetName(m_fd,
769  vntArgs.at(0).ulVal,
770  &vntRet->bstrVal);
771  break;
772  case ID_TASK_GETTAG:
773  hr = bCap_TaskGetTag(m_fd,
774  vntArgs.at(0).ulVal,
775  vntRet.get());
776  break;
777  case ID_TASK_PUTTAG:
778  hr = bCap_TaskPutTag(m_fd,
779  vntArgs.at(0).ulVal, vntArgs.at(1));
780  break;
781  case ID_TASK_GETID:
782  hr = bCap_TaskGetID(m_fd,
783  vntArgs.at(0).ulVal,
784  vntRet.get());
785  break;
786  case ID_TASK_PUTID:
787  hr = bCap_TaskPutID(m_fd,
788  vntArgs.at(0).ulVal, vntArgs.at(1));
789  break;
790  case ID_TASK_RELEASE:
791  tmpKH.second = vntArgs.at(0).ulVal;
792  hr = bCap_TaskRelease(m_fd,
793  &vntArgs.at(0).ulVal);
794  break;
795  // Variable
796  case ID_VARIABLE_GETDATETIME:
797  hr = bCap_VariableGetDateTime(m_fd,
798  vntArgs.at(0).ulVal,
799  vntRet.get());
800  break;
801  case ID_VARIABLE_GETVALUE:
802  hr = bCap_VariableGetValue(m_fd,
803  vntArgs.at(0).ulVal,
804  vntRet.get());
805  break;
806  case ID_VARIABLE_PUTVALUE:
807  hr = bCap_VariablePutValue(m_fd,
808  vntArgs.at(0).ulVal, vntArgs.at(1));
809  break;
810  case ID_VARIABLE_GETATTRIBUTE:
811  vntRet->vt = VT_I4;
812  hr = bCap_VariableGetAttribute(m_fd,
813  vntArgs.at(0).ulVal,
814  &vntRet->lVal);
815  break;
816  case ID_VARIABLE_GETHELP:
817  vntRet->vt = VT_BSTR;
818  hr = bCap_VariableGetHelp(m_fd,
819  vntArgs.at(0).ulVal,
820  &vntRet->bstrVal);
821  break;
822  case ID_VARIABLE_GETNAME:
823  vntRet->vt = VT_BSTR;
824  hr = bCap_VariableGetName(m_fd,
825  vntArgs.at(0).ulVal,
826  &vntRet->bstrVal);
827  break;
828  case ID_VARIABLE_GETTAG:
829  hr = bCap_VariableGetTag(m_fd,
830  vntArgs.at(0).ulVal,
831  vntRet.get());
832  break;
833  case ID_VARIABLE_PUTTAG:
834  hr = bCap_VariablePutTag(m_fd,
835  vntArgs.at(0).ulVal, vntArgs.at(1));
836  break;
837  case ID_VARIABLE_GETID:
838  hr = bCap_VariableGetID(m_fd,
839  vntArgs.at(0).ulVal,
840  vntRet.get());
841  break;
842  case ID_VARIABLE_PUTID:
843  hr = bCap_VariablePutID(m_fd,
844  vntArgs.at(0).ulVal, vntArgs.at(1));
845  break;
846  case ID_VARIABLE_GETMICROSECOND:
847  vntRet->vt = VT_I4;
848  hr = bCap_VariableGetMicrosecond(m_fd,
849  vntArgs.at(0).ulVal,
850  &vntRet->lVal);
851  break;
852  case ID_VARIABLE_RELEASE:
853  tmpKH.second = vntArgs.at(0).ulVal;
854  hr = bCap_VariableRelease(m_fd,
855  &vntArgs.at(0).ulVal);
856  break;
857  // Command
858  case ID_COMMAND_EXECUTE:
859  hr = bCap_CommandExecute(m_fd,
860  vntArgs.at(0).ulVal, vntArgs.at(1).lVal,
861  vntRet.get());
862  break;
863  case ID_COMMAND_CANCEL:
864  hr = bCap_CommandCancel(m_fd,
865  vntArgs.at(0).ulVal);
866  break;
867  case ID_COMMAND_GETTIMEOUT:
868  vntRet->vt = VT_I4;
869  hr = bCap_CommandGetTimeout(m_fd,
870  vntArgs.at(0).ulVal,
871  &vntRet->lVal);
872  break;
873  case ID_COMMAND_PUTTIMEOUT:
874  hr = bCap_CommandPutTimeout(m_fd,
875  vntArgs.at(0).ulVal, vntArgs.at(1).lVal);
876  break;
877  case ID_COMMAND_GETSTATE:
878  vntRet->vt = VT_I4;
879  hr = bCap_CommandGetState(m_fd,
880  vntArgs.at(0).ulVal,
881  &vntRet->lVal);
882  break;
883  case ID_COMMAND_GETPARAMETERS:
884  hr = bCap_CommandGetParameters(m_fd,
885  vntArgs.at(0).ulVal,
886  vntRet.get());
887  break;
888  case ID_COMMAND_PUTPARAMETERS:
889  hr = bCap_CommandPutParameters(m_fd,
890  vntArgs.at(0).ulVal, vntArgs.at(1));
891  break;
892  case ID_COMMAND_GETRESULT:
893  hr = bCap_CommandGetResult(m_fd,
894  vntArgs.at(0).ulVal,
895  vntRet.get());
896  break;
897  case ID_COMMAND_GETATTRIBUTE:
898  vntRet->vt = VT_I4;
899  hr = bCap_CommandGetAttribute(m_fd,
900  vntArgs.at(0).ulVal,
901  &vntRet->lVal);
902  break;
903  case ID_COMMAND_GETHELP:
904  vntRet->vt = VT_BSTR;
905  hr = bCap_CommandGetHelp(m_fd,
906  vntArgs.at(0).ulVal,
907  &vntRet->bstrVal);
908  break;
909  case ID_COMMAND_GETNAME:
910  vntRet->vt = VT_BSTR;
911  hr = bCap_CommandGetName(m_fd,
912  vntArgs.at(0).ulVal,
913  &vntRet->bstrVal);
914  break;
915  case ID_COMMAND_GETTAG:
916  hr = bCap_CommandGetTag(m_fd,
917  vntArgs.at(0).ulVal,
918  vntRet.get());
919  break;
920  case ID_COMMAND_PUTTAG:
921  hr = bCap_CommandPutTag(m_fd,
922  vntArgs.at(0).ulVal, vntArgs.at(1));
923  break;
924  case ID_COMMAND_GETID:
925  hr = bCap_CommandGetID(m_fd,
926  vntArgs.at(0).ulVal,
927  vntRet.get());
928  break;
929  case ID_COMMAND_PUTID:
930  hr = bCap_CommandPutID(m_fd,
931  vntArgs.at(0).ulVal, vntArgs.at(1));
932  break;
933  case ID_COMMAND_RELEASE:
934  tmpKH.second = vntArgs.at(0).ulVal;
935  hr = bCap_CommandRelease(m_fd,
936  &vntArgs.at(0).ulVal);
937  break;
938  case ID_MESSAGE_REPLY:
939  hr = bCap_MessageReply(m_fd,
940  vntArgs.at(0).ulVal, vntArgs.at(1));
941  break;
942  case ID_MESSAGE_CLEAR:
943  hr = bCap_MessageClear(m_fd,
944  vntArgs.at(0).ulVal);
945  break;
946  case ID_MESSAGE_GETDATETIME:
947  hr = bCap_MessageGetDateTime(m_fd,
948  vntArgs.at(0).ulVal,
949  vntRet.get());
950  break;
951  case ID_MESSAGE_GETDESCRIPTION:
952  vntRet->vt = VT_BSTR;
953  hr = bCap_MessageGetDescription(m_fd,
954  vntArgs.at(0).ulVal,
955  &vntRet->bstrVal);
956  break;
957  case ID_MESSAGE_GETDESTINATION:
958  vntRet->vt = VT_BSTR;
959  hr = bCap_MessageGetDestination(m_fd,
960  vntArgs.at(0).ulVal,
961  &vntRet->bstrVal);
962  break;
963  case ID_MESSAGE_GETNUMBER:
964  vntRet->vt = VT_I4;
965  hr = bCap_MessageGetNumber(m_fd,
966  vntArgs.at(0).ulVal,
967  &vntRet->lVal);
968  break;
969  case ID_MESSAGE_GETSERIALNUMBER:
970  vntRet->vt = VT_I4;
971  hr = bCap_MessageGetSerialNumber(m_fd,
972  vntArgs.at(0).ulVal,
973  &vntRet->lVal);
974  break;
975  case ID_MESSAGE_GETSOURCE:
976  vntRet->vt = VT_BSTR;
977  hr = bCap_MessageGetSource(m_fd,
978  vntArgs.at(0).ulVal,
979  &vntRet->bstrVal);
980  break;
981  case ID_MESSAGE_GETVALUE:
982  hr = bCap_MessageGetValue(m_fd,
983  vntArgs.at(0).ulVal,
984  vntRet.get());
985  break;
986  case ID_MESSAGE_RELEASE:
987  tmpKH.second = vntArgs.at(0).ulVal;
988  hr = bCap_MessageRelease(m_fd,
989  &vntArgs.at(0).ulVal);
990  break;
991  }
992  } catch(std::out_of_range&) {
993  hr = DISP_E_BADINDEX;
994  }
995 
996  if(hr == S_OK) {
997  if(tmpKH.first > 0) {
998  tmpKH.second = vntRet->ulVal;
999  m_vecKH.push_back(tmpKH);
1000  }
1001  else if(tmpKH.second > 0) {
1002  KeyHandle_Vec::iterator it;
1003  for(it = m_vecKH.begin(); it != m_vecKH.end(); it++) {
1004  if((func_id == it->first)
1005  && (tmpKH.second == it->second))
1006  {
1007  m_vecKH.erase(it);
1008  break;
1009  }
1010  }
1011  }
1012  }
1013 
1014  return hr;
1015 }
1016 
1017 }
1018 
bcap_service::BCAPService::m_retry
int m_retry
Definition: bcap_service.h:85
bCap_CommandPutID
HRESULT bCap_CommandPutID(int fd, uint32_t hCommand, VARIANT newVal)
ID_MESSAGE_GETSOURCE
#define ID_MESSAGE_GETSOURCE
bCap_TaskGetVariable
HRESULT bCap_TaskGetVariable(int fd, uint32_t hTask, BSTR bstrName, BSTR bstrOption, uint32_t *hVariable)
bCap_ControllerGetExtension
HRESULT bCap_ControllerGetExtension(int fd, uint32_t hController, BSTR bstrName, BSTR bstrOption, uint32_t *hExtension)
ID_FILE_GETHELP
#define ID_FILE_GETHELP
bCap_RobotHalt
HRESULT bCap_RobotHalt(int fd, uint32_t hRobot, BSTR bstrOption)
SysFreeString
void SysFreeString(BSTR bstr)
bCap_CommandGetParameters
HRESULT bCap_CommandGetParameters(int fd, uint32_t hCommand, VARIANT *pVal)
ID_COMMAND_GETATTRIBUTE
#define ID_COMMAND_GETATTRIBUTE
bCap_TaskGetID
HRESULT bCap_TaskGetID(int fd, uint32_t hTask, VARIANT *pVal)
ID_TASK_GETVARIABLE
#define ID_TASK_GETVARIABLE
bCap_FilePutValue
HRESULT bCap_FilePutValue(int fd, uint32_t hFile, VARIANT newVal)
bCap_ControllerGetAttribute
HRESULT bCap_ControllerGetAttribute(int fd, uint32_t hController, int32_t *pVal)
bCap_VariableGetAttribute
HRESULT bCap_VariableGetAttribute(int fd, uint32_t hVariable, int32_t *pVal)
bcap_service::BCAPService::m_port
int m_port
Definition: bcap_service.h:85
ID_VARIABLE_GETVALUE
#define ID_VARIABLE_GETVALUE
ID_FILE_RELEASE
#define ID_FILE_RELEASE
ID_CONTROLLER_GETROBOTNAMES
#define ID_CONTROLLER_GETROBOTNAMES
bcap_service::BCAPService::CallFunction
bool CallFunction(bcap::Request &req, bcap::Response &res)
Definition: bcap_service.cpp:238
uint32_t
unsigned uint32_t
bCap_RobotGetID
HRESULT bCap_RobotGetID(int fd, uint32_t hRobot, VARIANT *pVal)
ros::NodeHandle
bCap_MessageClear
HRESULT bCap_MessageClear(int fd, uint32_t hMessage)
bcap_service::BCAPService
Definition: bcap_service.h:51
ID_CONTROLLER_EXECUTE
#define ID_CONTROLLER_EXECUTE
bCap_FilePutTag
HRESULT bCap_FilePutTag(int fd, uint32_t hFile, VARIANT newVal)
bCap_ExtensionGetTag
HRESULT bCap_ExtensionGetTag(int fd, uint32_t hExtension, VARIANT *pVal)
bCap_CommandGetID
HRESULT bCap_CommandGetID(int fd, uint32_t hCommand, VARIANT *pVal)
ID_FILE_GETTAG
#define ID_FILE_GETTAG
ID_FILE_RUN
#define ID_FILE_RUN
ConvertRacStr2Variant
HRESULT ConvertRacStr2Variant(uint16_t vt, const char *chSrc, VARIANT *pvargDest)
bCap_MessageGetSource
HRESULT bCap_MessageGetSource(int fd, uint32_t hMessage, BSTR *pVal)
ID_ROBOT_DRIVE
#define ID_ROBOT_DRIVE
bCap_RobotPutTag
HRESULT bCap_RobotPutTag(int fd, uint32_t hRobot, VARIANT newVal)
ID_FILE_GETTYPE
#define ID_FILE_GETTYPE
bCap_ControllerGetVariableNames
HRESULT bCap_ControllerGetVariableNames(int fd, uint32_t hController, BSTR bstrOption, VARIANT *pVal)
bcap_service::BCAPService::m_fd
int m_fd
Definition: bcap_service.h:88
bCap_SetTimeout
HRESULT bCap_SetTimeout(int fd, uint32_t timeout)
bCap_RobotGoHome
HRESULT bCap_RobotGoHome(int fd, uint32_t hRobot)
bCap_ControllerGetVariable
HRESULT bCap_ControllerGetVariable(int fd, uint32_t hController, BSTR bstrName, BSTR bstrOption, uint32_t *hVariable)
ID_CONTROLLER_PUTTAG
#define ID_CONTROLLER_PUTTAG
ID_EXTENSION_PUTID
#define ID_EXTENSION_PUTID
ID_FILE_GETDATELASTMODIFIED
#define ID_FILE_GETDATELASTMODIFIED
bcap_service::BCAPService::m_timeout
int m_timeout
Definition: bcap_service.h:85
bCap_VariableRelease
HRESULT bCap_VariableRelease(int fd, uint32_t *hVariable)
bCap_ControllerGetTask
HRESULT bCap_ControllerGetTask(int fd, uint32_t hController, BSTR bstrName, BSTR bstrOption, uint32_t *hTask)
bcap_service::BCAPService::get_Retry
unsigned int get_Retry() const
Definition: bcap_service.cpp:222
bCap_VariablePutValue
HRESULT bCap_VariablePutValue(int fd, uint32_t hVariable, VARIANT newVal)
ID_TASK_GETVARIABLENAMES
#define ID_TASK_GETVARIABLENAMES
bCap_VariableGetMicrosecond
HRESULT bCap_VariableGetMicrosecond(int fd, uint32_t hVariable, int32_t *pVal)
ID_CONTROLLER_CONNECT
#define ID_CONTROLLER_CONNECT
bCap_FileGetDateLastModified
HRESULT bCap_FileGetDateLastModified(int fd, uint32_t hFile, VARIANT *pVal)
ID_EXTENSION_GETID
#define ID_EXTENSION_GETID
bCap_ExtensionPutID
HRESULT bCap_ExtensionPutID(int fd, uint32_t hExtension, VARIANT newVal)
ID_TASK_DELETE
#define ID_TASK_DELETE
bCap_CommandExecute
HRESULT bCap_CommandExecute(int fd, uint32_t hCommand, int32_t lMode, VARIANT *pVal)
bCap_ControllerGetCommandNames
HRESULT bCap_ControllerGetCommandNames(int fd, uint32_t hController, BSTR bstrOption, VARIANT *pVal)
S_OK
#define S_OK
ID_COMMAND_PUTID
#define ID_COMMAND_PUTID
bCap_ExtensionGetHelp
HRESULT bCap_ExtensionGetHelp(int fd, uint32_t hExtension, BSTR *pVal)
ros::Duration::sleep
bool sleep() const
bCap_FileGetFile
HRESULT bCap_FileGetFile(int fd, uint32_t hFile, BSTR bstrName, BSTR bstrOption, uint32_t *hFile2)
bCap_FileGetHelp
HRESULT bCap_FileGetHelp(int fd, uint32_t hFile, BSTR *pVal)
ID_EXTENSION_GETATTRIBUTE
#define ID_EXTENSION_GETATTRIBUTE
bcap_service::BCAPService::StartService
HRESULT StartService(ros::NodeHandle &node)
Definition: bcap_service.cpp:182
bcap_service::BCAPService::BCAPService
BCAPService()
Definition: bcap_service.cpp:60
ID_FILE_GETFILENAMES
#define ID_FILE_GETFILENAMES
ID_ROBOT_GETTAG
#define ID_ROBOT_GETTAG
bCap_TaskStop
HRESULT bCap_TaskStop(int fd, uint32_t hTask, int32_t lMode, BSTR bstrOption)
bCap_MessageReply
HRESULT bCap_MessageReply(int fd, uint32_t hMessage, VARIANT vntData)
bcap_service::BCAPService::ExecFunction
HRESULT ExecFunction(int32_t func_id, VARIANT_Vec &vntArgs, VARIANT_Ptr &vntRet)
Definition: bcap_service.cpp:279
bCap_TaskGetTag
HRESULT bCap_TaskGetTag(int fd, uint32_t hTask, VARIANT *pVal)
ros::init
ROSCPP_DECL void init(int &argc, char **argv, const std::string &name, uint32_t options=0)
BSTR
wchar_t * BSTR
bCap_FileGetVariable
HRESULT bCap_FileGetVariable(int fd, uint32_t hFile, BSTR bstrName, BSTR bstrOption, uint32_t *hVariable)
bCap_ServiceStop
HRESULT bCap_ServiceStop(int fd)
ID_FILE_PUTID
#define ID_FILE_PUTID
bCap_FileGetType
HRESULT bCap_FileGetType(int fd, uint32_t hFile, BSTR *pVal)
ID_MESSAGE_GETDATETIME
#define ID_MESSAGE_GETDATETIME
VARIANT_Vec
std::vector< VARIANT, VariantAllocator< VARIANT > > VARIANT_Vec
Definition: bcap_service.h:47
bCap_RobotGetAttribute
HRESULT bCap_RobotGetAttribute(int fd, uint32_t hRobot, int32_t *pVal)
ID_TASK_STOP
#define ID_TASK_STOP
bCap_CommandGetTimeout
HRESULT bCap_CommandGetTimeout(int fd, uint32_t hCommand, int32_t *pVal)
bCap_CommandGetName
HRESULT bCap_CommandGetName(int fd, uint32_t hCommand, BSTR *pVal)
ID_MESSAGE_GETVALUE
#define ID_MESSAGE_GETVALUE
ID_ROBOT_ROTATE
#define ID_ROBOT_ROTATE
bCap_FileGetTag
HRESULT bCap_FileGetTag(int fd, uint32_t hFile, VARIANT *pVal)
ID_VARIABLE_GETHELP
#define ID_VARIABLE_GETHELP
ID_ROBOT_EXECUTE
#define ID_ROBOT_EXECUTE
bCap_TaskGetName
HRESULT bCap_TaskGetName(int fd, uint32_t hTask, BSTR *pVal)
ID_ROBOT_UNCHUCK
#define ID_ROBOT_UNCHUCK
ID_EXTENSION_PUTTAG
#define ID_EXTENSION_PUTTAG
main
int main(int argc, char **argv)
Definition: bcap_service.cpp:32
bCap_RobotPutID
HRESULT bCap_RobotPutID(int fd, uint32_t hRobot, VARIANT newVal)
bCap_RobotGetName
HRESULT bCap_RobotGetName(int fd, uint32_t hRobot, BSTR *pVal)
DISP_E_BADINDEX
#define DISP_E_BADINDEX
ID_VARIABLE_RELEASE
#define ID_VARIABLE_RELEASE
bcap_service::BCAPService::put_Type
void put_Type(const std::string &type)
Definition: bcap_service.cpp:199
ID_ROBOT_GETATTRIBUTE
#define ID_ROBOT_GETATTRIBUTE
bCap_RobotRelease
HRESULT bCap_RobotRelease(int fd, uint32_t *hRobot)
ros::NodeHandle::advertiseService
ServiceServer advertiseService(const std::string &service, bool(T::*srv_func)(MReq &, MRes &), T *obj)
ID_TASK_RELEASE
#define ID_TASK_RELEASE
ID_ROBOT_UNHOLD
#define ID_ROBOT_UNHOLD
bCap_FileGetDateCreated
HRESULT bCap_FileGetDateCreated(int fd, uint32_t hFile, VARIANT *pVal)
bCap_Open_Client
HRESULT bCap_Open_Client(const char *connect, uint32_t timeout, unsigned int retry, int *pfd)
ID_FILE_GETVARIABLENAMES
#define ID_FILE_GETVARIABLENAMES
ID_FILE_EXECUTE
#define ID_FILE_EXECUTE
FAILED
#define FAILED(hr)
ID_VARIABLE_GETNAME
#define ID_VARIABLE_GETNAME
ID_CONTROLLER_GETMESSAGE
#define ID_CONTROLLER_GETMESSAGE
ID_TASK_GETID
#define ID_TASK_GETID
ID_TASK_GETFILENAME
#define ID_TASK_GETFILENAME
bCap_SetRetry
HRESULT bCap_SetRetry(int fd, unsigned int retry)
ID_MESSAGE_CLEAR
#define ID_MESSAGE_CLEAR
bCap_ControllerGetID
HRESULT bCap_ControllerGetID(int fd, uint32_t hController, VARIANT *pVal)
bCap_MessageGetValue
HRESULT bCap_MessageGetValue(int fd, uint32_t hMessage, VARIANT *pVal)
bCap_CommandGetHelp
HRESULT bCap_CommandGetHelp(int fd, uint32_t hCommand, BSTR *pVal)
bCap_TaskPutTag
HRESULT bCap_TaskPutTag(int fd, uint32_t hTask, VARIANT newVal)
bCap_TaskGetHelp
HRESULT bCap_TaskGetHelp(int fd, uint32_t hTask, BSTR *pVal)
VT_I4
VT_I4
bCap_RobotUnchuck
HRESULT bCap_RobotUnchuck(int fd, uint32_t hRobot, BSTR bstrOption)
ID_CONTROLLER_DISCONNECT
#define ID_CONTROLLER_DISCONNECT
bcap_service.h
ID_COMMAND_GETSTATE
#define ID_COMMAND_GETSTATE
bCap_RobotMove
HRESULT bCap_RobotMove(int fd, uint32_t hRobot, int32_t lComp, VARIANT vntPose, BSTR bstrOption)
ID_TASK_PUTTAG
#define ID_TASK_PUTTAG
ID_MESSAGE_RELEASE
#define ID_MESSAGE_RELEASE
E_INVALIDARG
#define E_INVALIDARG
VT_BSTR
VT_BSTR
ID_ROBOT_HOLD
#define ID_ROBOT_HOLD
ID_COMMAND_GETPARAMETERS
#define ID_COMMAND_GETPARAMETERS
bCap_TaskExecute
HRESULT bCap_TaskExecute(int fd, uint32_t hTask, BSTR bstrCommand, VARIANT vntParam, VARIANT *pVal)
bCap_CommandCancel
HRESULT bCap_CommandCancel(int fd, uint32_t hCommand)
bcap_service::BCAPService::m_type
std::string m_type
Definition: bcap_service.h:84
bCap_ControllerGetMessage
HRESULT bCap_ControllerGetMessage(int fd, uint32_t hController, uint32_t *hMessage)
ID_EXTENSION_GETVARIABLE
#define ID_EXTENSION_GETVARIABLE
bCap_VariableGetTag
HRESULT bCap_VariableGetTag(int fd, uint32_t hVariable, VARIANT *pVal)
ID_TASK_PUTID
#define ID_TASK_PUTID
bCap_FileGetID
HRESULT bCap_FileGetID(int fd, uint32_t hFile, VARIANT *pVal)
bCap_FileGetAttribute
HRESULT bCap_FileGetAttribute(int fd, uint32_t hFile, int32_t *pVal)
VT_EMPTY
VT_EMPTY
bCap_TaskPutID
HRESULT bCap_TaskPutID(int fd, uint32_t hTask, VARIANT newVal)
ID_FILE_GETVALUE
#define ID_FILE_GETVALUE
ID_FILE_PUTTAG
#define ID_FILE_PUTTAG
bcap_service::BCAPService::put_Timeout
void put_Timeout(uint32_t value)
Definition: bcap_service.cpp:215
bcap_service::BCAPService::m_addr
std::string m_addr
Definition: bcap_service.h:84
bCap_ExtensionGetVariableNames
HRESULT bCap_ExtensionGetVariableNames(int fd, uint32_t hExtension, BSTR bstrOption, VARIANT *pVal)
bCap_VariablePutID
HRESULT bCap_VariablePutID(int fd, uint32_t hVariable, VARIANT newVal)
ID_EXTENSION_RELEASE
#define ID_EXTENSION_RELEASE
VariantInit
void VariantInit(VARIANT *pvarg)
ID_ROBOT_ACCELERATE
#define ID_ROBOT_ACCELERATE
bCap_ControllerGetExtensionNames
HRESULT bCap_ControllerGetExtensionNames(int fd, uint32_t hController, BSTR bstrOption, VARIANT *pVal)
ID_VARIABLE_GETMICROSECOND
#define ID_VARIABLE_GETMICROSECOND
bCap_FileGetName
HRESULT bCap_FileGetName(int fd, uint32_t hFile, BSTR *pVal)
ID_FILE_GETNAME
#define ID_FILE_GETNAME
ID_TASK_GETTAG
#define ID_TASK_GETTAG
ID_FILE_GETID
#define ID_FILE_GETID
bCap_RobotChuck
HRESULT bCap_RobotChuck(int fd, uint32_t hRobot, BSTR bstrOption)
bCap_ServiceStart
HRESULT bCap_ServiceStart(int fd, BSTR bstrOption)
bCap_RobotUnhold
HRESULT bCap_RobotUnhold(int fd, uint32_t hRobot, BSTR bstrOption)
bcap_service::BCAPService::StopService
HRESULT StopService()
Definition: bcap_service.cpp:188
bCap_RobotGetHelp
HRESULT bCap_RobotGetHelp(int fd, uint32_t hRobot, BSTR *pVal)
bCap_ControllerGetCommand
HRESULT bCap_ControllerGetCommand(int fd, uint32_t hController, BSTR bstrName, BSTR bstrOption, uint32_t *hCommand)
bCap_ControllerGetHelp
HRESULT bCap_ControllerGetHelp(int fd, uint32_t hController, BSTR *pVal)
bcap_service::BCAPService::m_wdt
int m_wdt
Definition: bcap_service.h:91
ID_CONTROLLER_GETFILENAMES
#define ID_CONTROLLER_GETFILENAMES
HRESULT
int32_t HRESULT
bCap_ControllerGetTaskNames
HRESULT bCap_ControllerGetTaskNames(int fd, uint32_t hController, BSTR bstrOption, VARIANT *pVal)
ID_COMMAND_GETRESULT
#define ID_COMMAND_GETRESULT
bCap_ExtensionRelease
HRESULT bCap_ExtensionRelease(int fd, uint32_t *hExtension)
ID_VARIABLE_GETATTRIBUTE
#define ID_VARIABLE_GETATTRIBUTE
bCap_TaskRelease
HRESULT bCap_TaskRelease(int fd, uint32_t *hTask)
bCap_RobotExecute
HRESULT bCap_RobotExecute(int fd, uint32_t hRobot, BSTR bstrCommand, VARIANT vntParam, VARIANT *pVal)
ID_CONTROLLER_GETCOMMAND
#define ID_CONTROLLER_GETCOMMAND
ID_FILE_GETFILE
#define ID_FILE_GETFILE
ID_TASK_START
#define ID_TASK_START
bCap_VariableGetName
HRESULT bCap_VariableGetName(int fd, uint32_t hVariable, BSTR *pVal)
ID_VARIABLE_GETDATETIME
#define ID_VARIABLE_GETDATETIME
SysAllocString
BSTR SysAllocString(const wchar_t *sz)
ID_MESSAGE_GETSERIALNUMBER
#define ID_MESSAGE_GETSERIALNUMBER
ID_COMMAND_GETTIMEOUT
#define ID_COMMAND_GETTIMEOUT
bCap_MessageRelease
HRESULT bCap_MessageRelease(int fd, uint32_t *hMessage)
bCap_CommandPutParameters
HRESULT bCap_CommandPutParameters(int fd, uint32_t hCommand, VARIANT newVal)
ID_MESSAGE_REPLY
#define ID_MESSAGE_REPLY
VT_UI4
VT_UI4
bCap_FileGetVariableNames
HRESULT bCap_FileGetVariableNames(int fd, uint32_t hFile, BSTR bstrOption, VARIANT *pVal)
ID_CONTROLLER_PUTID
#define ID_CONTROLLER_PUTID
bcap_service::BCAPService::m_vecKH
KeyHandle_Vec m_vecKH
Definition: bcap_service.h:94
bCap_ControllerExecute
HRESULT bCap_ControllerExecute(int fd, uint32_t hController, BSTR bstrCommand, VARIANT vntParam, VARIANT *pVal)
ConvertVariant2RacStr
HRESULT ConvertVariant2RacStr(VARIANT varSrc, char **chDest)
ID_CONTROLLER_GETTAG
#define ID_CONTROLLER_GETTAG
bCap_VariablePutTag
HRESULT bCap_VariablePutTag(int fd, uint32_t hVariable, VARIANT newVal)
ID_TASK_GETATTRIBUTE
#define ID_TASK_GETATTRIBUTE
VARIANT_Ptr
boost::interprocess::unique_ptr< VARIANT, variant_deleter > VARIANT_Ptr
Definition: bcap_service.h:46
bCap_ControllerPutID
HRESULT bCap_ControllerPutID(int fd, uint32_t hController, VARIANT newVal)
ID_ROBOT_GETHELP
#define ID_ROBOT_GETHELP
bCap_FileMove
HRESULT bCap_FileMove(int fd, uint32_t hFile, BSTR bstrName, BSTR bstrOption)
bCap_ControllerConnect
HRESULT bCap_ControllerConnect(int fd, BSTR bstrName, BSTR bstrProvider, BSTR bstrMachine, BSTR bstrOption, uint32_t *hController)
bCap_FilePutID
HRESULT bCap_FilePutID(int fd, uint32_t hFile, VARIANT newVal)
ID_ROBOT_GETVARIABLENAMES
#define ID_ROBOT_GETVARIABLENAMES
ID_MESSAGE_GETDESCRIPTION
#define ID_MESSAGE_GETDESCRIPTION
bCap_CommandGetState
HRESULT bCap_CommandGetState(int fd, uint32_t hCommand, int32_t *pVal)
ID_ROBOT_PUTID
#define ID_ROBOT_PUTID
bCap_VariableGetID
HRESULT bCap_VariableGetID(int fd, uint32_t hVariable, VARIANT *pVal)
bcap_service::BCAPService::Disconnect
HRESULT Disconnect()
Definition: bcap_service.cpp:139
SUCCEEDED
#define SUCCEEDED(hr)
bCap_FileDelete
HRESULT bCap_FileDelete(int fd, uint32_t hFile, BSTR bstrOption)
ID_COMMAND_GETNAME
#define ID_COMMAND_GETNAME
ros::spin
ROSCPP_DECL void spin()
bCap_ControllerGetName
HRESULT bCap_ControllerGetName(int fd, uint32_t hController, BSTR *pVal)
bCap_ControllerGetFileNames
HRESULT bCap_ControllerGetFileNames(int fd, uint32_t hController, BSTR bstrOption, VARIANT *pVal)
bCap_ControllerGetTag
HRESULT bCap_ControllerGetTag(int fd, uint32_t hController, VARIANT *pVal)
bcap_service::BCAPService::m_invoke
int m_invoke
Definition: bcap_service.h:91
bcap_service::BCAPService::m_svr
ros::ServiceServer m_svr
Definition: bcap_service.h:97
ID_EXTENSION_GETNAME
#define ID_EXTENSION_GETNAME
bCap_VariableGetHelp
HRESULT bCap_VariableGetHelp(int fd, uint32_t hVariable, BSTR *pVal)
ID_VARIABLE_PUTTAG
#define ID_VARIABLE_PUTTAG
ID_ROBOT_GETVARIABLE
#define ID_ROBOT_GETVARIABLE
bCap_CommandGetTag
HRESULT bCap_CommandGetTag(int fd, uint32_t hCommand, VARIANT *pVal)
bCap_RobotDrive
HRESULT bCap_RobotDrive(int fd, uint32_t hRobot, int32_t lNo, float fMov, BSTR bstrOption)
ID_ROBOT_GETNAME
#define ID_ROBOT_GETNAME
bCap_CommandGetAttribute
HRESULT bCap_CommandGetAttribute(int fd, uint32_t hCommand, int32_t *pVal)
bCap_RobotAccelerate
HRESULT bCap_RobotAccelerate(int fd, uint32_t hRobot, int32_t lAxis, float fAccel, float fDecel)
bcap_service::BCAPService::m_wait
int m_wait
Definition: bcap_service.h:85
bCap_ExtensionGetAttribute
HRESULT bCap_ExtensionGetAttribute(int fd, uint32_t hExtension, int32_t *pVal)
ID_CONTROLLER_GETTASKNAMES
#define ID_CONTROLLER_GETTASKNAMES
bCap_RobotGetVariable
HRESULT bCap_RobotGetVariable(int fd, uint32_t hRobot, BSTR bstrName, BSTR bstrOption, uint32_t *hVariable)
ID_VARIABLE_PUTVALUE
#define ID_VARIABLE_PUTVALUE
ID_ROBOT_CHANGE
#define ID_ROBOT_CHANGE
ID_FILE_MOVE
#define ID_FILE_MOVE
ID_FILE_GETDATELASTACCESSED
#define ID_FILE_GETDATELASTACCESSED
ID_COMMAND_RELEASE
#define ID_COMMAND_RELEASE
ID_FILE_GETSIZE
#define ID_FILE_GETSIZE
ID_ROBOT_SPEED
#define ID_ROBOT_SPEED
bCap_CommandGetResult
HRESULT bCap_CommandGetResult(int fd, uint32_t hCommand, VARIANT *pVal)
bCap_RobotHold
HRESULT bCap_RobotHold(int fd, uint32_t hRobot, BSTR bstrOption)
ID_FILE_GETDATECREATED
#define ID_FILE_GETDATECREATED
ID_FILE_GETPATH
#define ID_FILE_GETPATH
bCap_ControllerGetFile
HRESULT bCap_ControllerGetFile(int fd, uint32_t hController, BSTR bstrName, BSTR bstrOption, uint32_t *hFile)
bCap_FileCopy
HRESULT bCap_FileCopy(int fd, uint32_t hFile, BSTR bstrName, BSTR bstrOption)
ID_FILE_PUTVALUE
#define ID_FILE_PUTVALUE
ID_ROBOT_PUTTAG
#define ID_ROBOT_PUTTAG
bCap_ExtensionExecute
HRESULT bCap_ExtensionExecute(int fd, uint32_t hExtension, BSTR bstrCommand, VARIANT vntParam, VARIANT *pVal)
KeyHandle
std::pair< int32_t, uint32_t > KeyHandle
Definition: bcap_service.h:36
ID_CONTROLLER_GETNAME
#define ID_CONTROLLER_GETNAME
ID_EXTENSION_GETTAG
#define ID_EXTENSION_GETTAG
bCap_CommandRelease
HRESULT bCap_CommandRelease(int fd, uint32_t *hCommand)
int32_t
int int32_t
bCap_CommandPutTag
HRESULT bCap_CommandPutTag(int fd, uint32_t hCommand, VARIANT newVal)
bCap_VariableGetValue
HRESULT bCap_VariableGetValue(int fd, uint32_t hVariable, VARIANT *pVal)
bCap_MessageGetSerialNumber
HRESULT bCap_MessageGetSerialNumber(int fd, uint32_t hMessage, int32_t *pVal)
ID_FILE_DELETE
#define ID_FILE_DELETE
bCap_FileExecute
HRESULT bCap_FileExecute(int fd, uint32_t hFile, BSTR bstrCommand, VARIANT vntParam, VARIANT *pVal)
ros::NodeHandle::getParam
bool getParam(const std::string &key, std::string &s) const
bCap_RobotRotate
HRESULT bCap_RobotRotate(int fd, uint32_t hRobot, VARIANT vntRotSuf, float fDeg, VARIANT vntPivot, BSTR bstrOption)
bCap_Close_Client
HRESULT bCap_Close_Client(int *pfd)
ID_MESSAGE_GETNUMBER
#define ID_MESSAGE_GETNUMBER
ID_TASK_GETHELP
#define ID_TASK_GETHELP
bCap_FileRun
HRESULT bCap_FileRun(int fd, uint32_t hFile, BSTR bstrOption, BSTR *pVal)
ID_CONTROLLER_GETEXTENSION
#define ID_CONTROLLER_GETEXTENSION
bCap_RobotSpeed
HRESULT bCap_RobotSpeed(int fd, uint32_t hRobot, int32_t lAxis, float fSpeed)
ID_CONTROLLER_GETHELP
#define ID_CONTROLLER_GETHELP
bCap_GetRetry
HRESULT bCap_GetRetry(int fd, unsigned int *retry)
ID_MESSAGE_GETDESTINATION
#define ID_MESSAGE_GETDESTINATION
bCap_GetTimeout
HRESULT bCap_GetTimeout(int fd, uint32_t *timeout)
bCap_ControllerGetRobotNames
HRESULT bCap_ControllerGetRobotNames(int fd, uint32_t hController, BSTR bstrOption, VARIANT *pVal)
bCap_FileGetPath
HRESULT bCap_FileGetPath(int fd, uint32_t hFile, BSTR *pVal)
ID_COMMAND_PUTTIMEOUT
#define ID_COMMAND_PUTTIMEOUT
bcap_service::BCAPService::Connect
HRESULT Connect()
Definition: bcap_service.cpp:119
bCap_TaskDelete
HRESULT bCap_TaskDelete(int fd, uint32_t hTask, BSTR bstrOption)
ID_COMMAND_GETTAG
#define ID_COMMAND_GETTAG
ID_CONTROLLER_GETTASK
#define ID_CONTROLLER_GETTASK
bcap_service
Definition: bcap_service.h:49
ID_CONTROLLER_GETROBOT
#define ID_CONTROLLER_GETROBOT
bCap_RobotChange
HRESULT bCap_RobotChange(int fd, uint32_t hRobot, BSTR bstrName)
ID_EXTENSION_GETHELP
#define ID_EXTENSION_GETHELP
bcap_service::BCAPService::~BCAPService
virtual ~BCAPService()
Definition: bcap_service.cpp:68
ID_ROBOT_MOVE
#define ID_ROBOT_MOVE
bCap_TaskGetAttribute
HRESULT bCap_TaskGetAttribute(int fd, uint32_t hTask, int32_t *pVal)
bCap_CommandPutTimeout
HRESULT bCap_CommandPutTimeout(int fd, uint32_t hCommand, int32_t newVal)
bCap_FileGetFileNames
HRESULT bCap_FileGetFileNames(int fd, uint32_t hFile, BSTR bstrOption, VARIANT *pVal)
ID_COMMAND_GETID
#define ID_COMMAND_GETID
ID_CONTROLLER_GETATTRIBUTE
#define ID_CONTROLLER_GETATTRIBUTE
bCap_ControllerPutTag
HRESULT bCap_ControllerPutTag(int fd, uint32_t hController, VARIANT newVal)
ID_EXTENSION_EXECUTE
#define ID_EXTENSION_EXECUTE
ID_CONTROLLER_GETVARIABLENAMES
#define ID_CONTROLLER_GETVARIABLENAMES
ID_ROBOT_HALT
#define ID_ROBOT_HALT
bcap_service::BCAPService::get_Timeout
uint32_t get_Timeout() const
Definition: bcap_service.cpp:206
ID_CONTROLLER_GETCOMMANDNAMES
#define ID_CONTROLLER_GETCOMMANDNAMES
ID_VARIABLE_GETTAG
#define ID_VARIABLE_GETTAG
ID_COMMAND_CANCEL
#define ID_COMMAND_CANCEL
bCap_FileGetValue
HRESULT bCap_FileGetValue(int fd, uint32_t hFile, VARIANT *pVal)
ID_TASK_EXECUTE
#define ID_TASK_EXECUTE
ID_CONTROLLER_GETFILE
#define ID_CONTROLLER_GETFILE
ID_COMMAND_GETHELP
#define ID_COMMAND_GETHELP
ID_ROBOT_CHUCK
#define ID_ROBOT_CHUCK
bCap_RobotGetVariableNames
HRESULT bCap_RobotGetVariableNames(int fd, uint32_t hRobot, BSTR bstrOption, VARIANT *pVal)
ID_COMMAND_PUTPARAMETERS
#define ID_COMMAND_PUTPARAMETERS
ID_FILE_COPY
#define ID_FILE_COPY
bCap_MessageGetDescription
HRESULT bCap_MessageGetDescription(int fd, uint32_t hMessage, BSTR *pVal)
bCap_ExtensionGetID
HRESULT bCap_ExtensionGetID(int fd, uint32_t hExtension, VARIANT *pVal)
bCap_MessageGetNumber
HRESULT bCap_MessageGetNumber(int fd, uint32_t hMessage, int32_t *pVal)
ID_ROBOT_GETID
#define ID_ROBOT_GETID
bCap_ControllerGetRobot
HRESULT bCap_ControllerGetRobot(int fd, uint32_t hController, BSTR bstrName, BSTR bstrOption, uint32_t *hRobot)
ID_TASK_GETNAME
#define ID_TASK_GETNAME
ID_FILE_GETVARIABLE
#define ID_FILE_GETVARIABLE
ID_CONTROLLER_GETID
#define ID_CONTROLLER_GETID
ID_FILE_GETATTRIBUTE
#define ID_FILE_GETATTRIBUTE
ROS_ERROR
#define ROS_ERROR(...)
ID_COMMAND_PUTTAG
#define ID_COMMAND_PUTTAG
bCap_FileGetDateLastAccessed
HRESULT bCap_FileGetDateLastAccessed(int fd, uint32_t hFile, VARIANT *pVal)
bCap_ControllerDisconnect
HRESULT bCap_ControllerDisconnect(int fd, uint32_t *hController)
bCap_MessageGetDestination
HRESULT bCap_MessageGetDestination(int fd, uint32_t hMessage, BSTR *pVal)
bCap_VariableGetDateTime
HRESULT bCap_VariableGetDateTime(int fd, uint32_t hVariable, VARIANT *pVal)
bcap_service::BCAPService::put_Retry
void put_Retry(unsigned int value)
Definition: bcap_service.cpp:231
bCap_ExtensionGetName
HRESULT bCap_ExtensionGetName(int fd, uint32_t hExtension, BSTR *pVal)
bCap_MessageGetDateTime
HRESULT bCap_MessageGetDateTime(int fd, uint32_t hMessage, VARIANT *pVal)
ID_CONTROLLER_GETEXTENSIONNAMES
#define ID_CONTROLLER_GETEXTENSIONNAMES
bcap_service::BCAPService::parseParams
void parseParams()
Definition: bcap_service.cpp:74
bCap_FileRelease
HRESULT bCap_FileRelease(int fd, uint32_t *hFile)
ID_VARIABLE_GETID
#define ID_VARIABLE_GETID
ID_EXTENSION_GETVARIABLENAMES
#define ID_EXTENSION_GETVARIABLENAMES
bCap_ExtensionPutTag
HRESULT bCap_ExtensionPutTag(int fd, uint32_t hExtension, VARIANT newVal)
ID_VARIABLE_PUTID
#define ID_VARIABLE_PUTID
bCap_TaskGetVariableNames
HRESULT bCap_TaskGetVariableNames(int fd, uint32_t hTask, BSTR bstrOption, VARIANT *pVal)
bCap_FileGetSize
HRESULT bCap_FileGetSize(int fd, uint32_t hFile, int32_t *pVal)
ID_ROBOT_GOHOME
#define ID_ROBOT_GOHOME
ID_CONTROLLER_GETVARIABLE
#define ID_CONTROLLER_GETVARIABLE
ID_ROBOT_RELEASE
#define ID_ROBOT_RELEASE
bCap_TaskGetFileName
HRESULT bCap_TaskGetFileName(int fd, uint32_t hTask, BSTR *pVal)
bcap_service::BCAPService::get_Type
const std::string & get_Type() const
Definition: bcap_service.cpp:194
bCap_TaskStart
HRESULT bCap_TaskStart(int fd, uint32_t hTask, int32_t lMode, BSTR bstrOption)
bCap_RobotGetTag
HRESULT bCap_RobotGetTag(int fd, uint32_t hRobot, VARIANT *pVal)
ID_COMMAND_EXECUTE
#define ID_COMMAND_EXECUTE
bCap_ExtensionGetVariable
HRESULT bCap_ExtensionGetVariable(int fd, uint32_t hExtension, BSTR bstrName, BSTR bstrOption, uint32_t *hVariable)

bcap_service
Author(s): DENSO WAVE INCORPORATED
autogenerated on Mon Jun 10 2019 13:12:23