b-Cap.c
Go to the documentation of this file.
1 
11 /*
12 [NOTES]
13  This is a sample source code. Copy and modify this code in accordance with a device and a device version. Especially please note timeout and timeout-retry settings.
14 */
15 
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <string.h>
19 #include <time.h>
20 
21 /* OS Switching */
22 #ifdef WIN32
23  /* Windows */
24 #include <winsock2.h>
25 #pragma comment(lib, "wsock32.lib")
26 
27 #else
28  /* Other */
29 #include <unistd.h>
30 
31 #include <sys/types.h>
32 #include <sys/socket.h>
33 #include <arpa/inet.h>
34 #include <netinet/in.h>
35 #include <netdb.h>
36 #include <fcntl.h>
37 #include <termios.h>
38 #endif
39 
40 
41 /* b-CAP functions */
42 #include "denso_ros_control/b-Cap.h"
43 
44 
45 /* ENDIAN switching */
46 #if !defined(__LITTLE_ENDIAN__)
47 #if !defined(__BIG_ENDIAN__)
48 
49 #if __BYTE_ORDER == __LITTLE_ENDIAN
50 #define __LITTLE_ENDIAN__
51 #elif __BYTE_ORDER == __BIG_ENDIAN
52 #define __BIG_ENDIAN__
53 #endif
54 
55 #endif
56 #endif
57 
58 /* DEBUG */
59 /* #define DEBUG 1 Set to debug mode */
60 
61 #ifdef DEBUG
62 #define DebugPrint( message ) fprintf( stderr, message )
63 #define DebugPrint2( f, a, b ) fprintf( stderr, f, a, b )
64 #else
65 #define DebugPrint( message )
66 #define DebugPrint2( f, a, b )
67 #endif
68 
69 
70 /* Constant values */
71 
72 /* length of temporary string buffer */
73 #define LOCALBUFFER_SZ 1024
74 /* length of temporary recieve buffer (must be >= 16bytes) */
75 #define LOCALRECBUFFER_SZ 1024
76 
77 
78 /* b-CAP packet constant */
79 #define BCAP_SOH 0x01 /* size of packet header(SOH) */
80 #define BCAP_EOT 0x04 /* size of packet terminater(EOT) */
81 #define BCAP_SIZE_SOH 1 /* size of header(SOH) */
82 #define BCAP_SIZE_EOT 1 /* size of terminater(EOT) */
83 #define BCAP_SIZE_LEN 4 /* size of message size */
84 #define BCAP_SIZE_SERIAL 2 /* size of serial number */
85 #define BCAP_SIZE_RESERVE 2 /* size of reserved */
86 #define BCAP_SIZE_FUNCID 4 /* size of FunctionID */
87 #define BCAP_SIZE_ARGNUM 2 /* size of Args */
88 #define BCAP_SIZE_CRC 2 /* size of CRC */
89 
90  /* b-CAP Packet header size */
91 #define BCAP_SIZE_BASE (BCAP_SIZE_SOH + BCAP_SIZE_EOT + \
92  BCAP_SIZE_LEN + BCAP_SIZE_SERIAL + \
93  BCAP_SIZE_RESERVE + BCAP_SIZE_FUNCID + \
94  BCAP_SIZE_ARGNUM)
95 
96 
97 /* b-CAP argument constant */
98 #define BCAP_SIZE_ARGLEN 4 /* size of length */
99 #define BCAP_SIZE_ARGTYPE 2 /* size of type */
100 #define BCAP_SIZE_ARGARRAYS 4 /* size of arrays */
101 #define BCAP_SIZE_ARGBASE (BCAP_SIZE_ARGLEN+BCAP_SIZE_ARGTYPE+BCAP_SIZE_ARGARRAYS)
102  /* b-CAP Arg header size */
103 #define BCAP_SIZE_ARGSTRLEN 4 /* size of string length */
104 
105 
106 #define BCAP_MAX_PACKET_SIZE 0x1000000 /* max packet size (bytes) */
107 #define BCAP_MAX_ARG_SIZE 0x1000000 /* max arg size (bytes) */
108 
109 
110 /* b-CAP function IDs */
111 #define BCAP_FUNC_Service_Start 1
112 #define BCAP_FUNC_Service_Stop 2
113 #define BCAP_FUNC_Controller_Connect 3
114 #define BCAP_FUNC_Controller_Disconnect 4
115 #define BCAP_FUNC_Controller_GetRobot 7
116 #define BCAP_FUNC_Controller_GetTask 8
117 #define BCAP_FUNC_Controller_GetVariable 9
118 #define BCAP_FUNC_Controller_Execute 17
119 
120 #define BCAP_FUNC_Robot_GetVariable 62
121 #define BCAP_FUNC_Robot_Execute 64
122 #define BCAP_FUNC_Robot_Change 66
123 #define BCAP_FUNC_Robot_Move 72
124 #define BCAP_FUNC_Robot_Release 84
125 
126 #define BCAP_FUNC_Task_GetVariable 85
127 #define BCAP_FUNC_Task_Start 88
128 #define BCAP_FUNC_Task_Stop 89
129 #define BCAP_FUNC_Task_Release 99
130 
131 #define BCAP_FUNC_Variable_PutValue 102
132 #define BCAP_FUNC_Variable_GetValue 101
133 #define BCAP_FUNC_Variable_PutValue 102
134 #define BCAP_FUNC_Variable_Release 111
135 
136 /* b-CAP Argment structure */
141 typedef struct BCAP_ARG {
142  u_int lLength;
143 
144  u_short iType;
145  u_int lArrays;
146  void *data;
147 
148  struct BCAP_ARG *pNextArg; /* pointer to the next argument */
149 } BCAP_ARG;
150 
151 /* b-CAP Packet structure */
156 typedef struct BCAP_PACKET {
157 
158  u_int lMsgLength;
159 
160  u_short iSerialNo;
161  u_short iReserved;
162 
163  u_int lFuncID;
164 
165  u_short iArgs;
166 
167  struct BCAP_ARG *pArg; /* pointer to the first argment */
168 } BCAP_PACKET;
169 
170 
171 /* module function prototypes */
172 static BCAP_HRESULT Packet_Send(int iSd, BCAP_PACKET *pPacket);
173 
174 /* packet class */
175 static BCAP_PACKET *Packet_Create(u_int lFuncID);
176 static void Packet_Release( BCAP_PACKET *pPacket); /* Release allocated packet and the arguments */
177 static BCAP_HRESULT Packet_Serialize(BCAP_PACKET *pPacket, void *pBinData ); /* struct ---> bin */
178 static BCAP_HRESULT Packet_Deserialize(void *pBinData, BCAP_PACKET *pPacket ); /* bin ---> struct */
179 static BCAP_HRESULT Packet_AddArg( BCAP_PACKET *pPacket, BCAP_ARG *pNewArg);
180 static BCAP_HRESULT Packet_GetResult( BCAP_PACKET *pRecPacket, void *pResult);
181 
182 /* argument class */
183 static BCAP_ARG *Arg_Create( u_short iType, u_int lArrays, u_int lLength, void *data);
184 static void Arg_Release( BCAP_ARG *pArg); /* free the allocated argument */
185 /* static BCAP_HRESULT Arg_Serialize(void *pBinData); */ /* bin <--- struct */
186 /* static BCAP_HRESULT Arg_Deserialize(BCAP_ARG *pArg, void *pBinData); */ /* struct <--- bin */
187 
188 /* module socket utility functions */
189 static BCAP_HRESULT bCapSendAndRec(int iSockFd, BCAP_PACKET *pSndPacket, BCAP_PACKET *pRecPacket);
190 static BCAP_HRESULT sendBinary(int iSockFd, u_char *pBuff, u_int lSize);
191 static u_char *receivePacket(int iSockFd, int* retryp);
192 
193 /* module utility functions */
194 static u_int sizeOfVariant(BCAP_VARIANT vntValue);
195 static u_int copyVariantFromArg(BCAP_VARIANT *pVntDst, BCAP_ARG *pArg);
196 /* static u_int copyArgValue(void *pDst, BCAP_ARG *pArg); */
197 
198 static u_int sizeOfVarType(u_short iType);
199 static u_int copyValue(void *pDst, void *pVntValue, u_int lLength);
200 static u_int copyToBSTR(void *pbDstPtr, void *pbSrcPtr);
201 static u_int copyFromBSTR(void *pDstAsciiPtr, void *pSrcBstrPtr);
202 static void *bMalloc(size_t size);
203 static void bFree(void *pPtr);
204 
205 /* module variables */
206 static u_short m_iSerialNo = 1; /* packet serial number: cyclic from 0x0001 to 0xFFFF */
207 
208 #ifdef BCAP_CONNECTION_UDP
209 static struct sockaddr_in m_sockServerAddr; /* server's socket address */
210 #endif
211 
212 /*--------------------------------------------------------------------
213  b-Cap library public functions
214  --------------------------------------------------------------------*/
215 
216 
225 BCAP_HRESULT bCap_Open(const char *pIPStr, int iPort, int *iSockFd) {
226 
227  BCAP_HRESULT hr = BCAP_E_FAIL;
228 
229 #ifdef BCAP_CONNECTION_COM
230 
231 #ifdef WIN32
232  BOOL bRet;
233  char szFileName[16];
234  DCB dcb;
235  HANDLE hSerial;
236 
237  COMMTIMEOUTS stTimeOut;
238 
239  sprintf(szFileName, "//./COM%d", iPort);
240  hSerial = CreateFile(szFileName, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
241  if (GetCommState(hSerial, &dcb)) {
242  dcb.BaudRate = SERIAL_BAUDRATE;
243  dcb.ByteSize = 8;
244  dcb.Parity = NOPARITY;
245  dcb.StopBits = ONESTOPBIT;
246  dcb.fOutX = FALSE;
247  dcb.fInX = FALSE;
248  dcb.fOutxCtsFlow = FALSE;
249  dcb.fRtsControl = RTS_CONTROL_ENABLE;
250  dcb.fOutxDsrFlow = FALSE;
251  dcb.fDtrControl = DTR_CONTROL_ENABLE;
252  dcb.fDsrSensitivity = FALSE;
253 
254  bRet = SetCommState(hSerial, &dcb);
255 
256  /* timeout setting */
257  stTimeOut.ReadIntervalTimeout = MAXDWORD ;
258  stTimeOut.ReadTotalTimeoutMultiplier = MAXDWORD ;
259  stTimeOut.ReadTotalTimeoutConstant = 1000;
260  stTimeOut.WriteTotalTimeoutMultiplier = MAXDWORD;
261  stTimeOut.WriteTotalTimeoutConstant = 1000;
262  bRet = SetCommTimeouts( hSerial, &stTimeOut );
263 
264  *iSockFd = (int)hSerial;
265  hr = BCAP_S_OK;
266  }
267 #else
268  struct termios tio;
269  char dev[16];
270 
271  sprintf(dev, "/dev/ttyS%d", iPort);
272  *iSockFd = open(dev, O_RDWR | O_NOCTTY | O_NONBLOCK)
273 
274  bzero(&tio, sizeof(tio));
275  tio.c_cflag = SERIAL_BAUDRATE | CS8 | CLOCAL | CREAD;
276  tio.c_iflag = IGNPAR;
277  tio.c_oflag = 0;
278  tio.c_lflag = 0;
279  tio.c_cc[VTIME] = 0;
280  tio.c_cc[VMIN] = 1;
281 
282  tcflush(*iSockFd, TCIFLUSH);
283  tcsetattr(*iSockFd, TCSANOW, &tio);
284  fcntl(*iSockFd, F_SETFL, FNDELAY);
285 #endif
286 
287 #else
288  struct sockaddr_in serverAddr; /* server's socket address */
289  int sockAddrSize; /* size of socket address structure */
290 
291 #ifdef WIN32
292  WSADATA wsaData;
293  WSAStartup(MAKEWORD(2,0), &wsaData);
294 #endif
295 
296  sockAddrSize = sizeof( struct sockaddr_in);
297  memset( (char *)&serverAddr, 0, sockAddrSize);
298  serverAddr.sin_family = AF_INET;
299 
300  serverAddr.sin_port = htons((short)iPort); /* SERVER_PORT_NUM */
301 
302 #ifdef WIN32
303  serverAddr.sin_addr.S_un.S_addr = inet_addr(pIPStr); /* SERVER_IP_ADDRESS */
304 #else
305  serverAddr.sin_addr.s_addr = inet_addr(pIPStr); /* SERVER_IP_ADDRESS */
306 /* serverAddr.sin_len = (u_char)sockAddrSize;
307  inet_aton(pIPStr, &(serverAddr.sin_addr));*/
308 #endif
309 
310 #ifdef BCAP_CONNECTION_UDP
311  memcpy( (char *)&m_sockServerAddr, (char *)&serverAddr, sockAddrSize);
312  /* socket */
313  if( (*iSockFd = socket( AF_INET, SOCK_DGRAM, 0)) == -1) {
314  perror( "Fail.. Function:socket(UDP) in bCap_Open()");
315  hr = BCAP_E_UNEXPECTED;
316  }
317  else{
318  hr = BCAP_S_OK;
319  struct timeval tv;
320  tv.tv_sec = 0;
321  tv.tv_usec = 20000; /* 20msec */
322  if (setsockopt(*iSockFd, SOL_SOCKET, SO_RCVTIMEO,&tv,sizeof(tv)) < 0) {
323  perror("Error");
324  }
325  }
326 #else /* TCP */
327  /* socket */
328  if( (*iSockFd = socket( AF_INET, SOCK_STREAM, 0)) == -1) {
329  perror( "Fail.. Function:socket(TCP) in bCap_Open()");
330  hr = BCAP_E_UNEXPECTED;
331  }
332  else{
333  /* connect to server */
334  int iResult;
335  iResult = connect(*iSockFd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
336 
337  if (iResult == 0){
338  hr = BCAP_S_OK;
339  }
340  else{
341  hr = BCAP_E_UNEXPECTED;
342  }
343  }
344 #endif
345 #endif
346 
347  return hr;
348 }
349 
350 
359 BCAP_HRESULT bCap_Close(int iSockFd){
360 
361  BCAP_HRESULT hr = BCAP_E_FAIL;
362 
363 #ifdef BCAP_CONNECTION_COM
364 #ifdef WIN32
365  CloseHandle((HANDLE)iSockFd);
366 #else
367  close(iSockFd);
368 #endif
369  hr = BCAP_S_OK;
370 #else
371 #ifdef WIN32
372  shutdown(iSockFd, SD_BOTH);
373  closesocket(iSockFd);
374  if (WSACleanup() == 0){
375  hr = BCAP_S_OK;
376  }
377 #else
378  shutdown(iSockFd, SHUT_RDWR);
379  close(iSockFd);
380  hr = BCAP_S_OK;
381 #endif
382 #endif
383 
384  return hr;
385 }
386 
387 
396 BCAP_HRESULT bCap_ServiceStart(int iSockFd){
397  BCAP_PACKET *pPacket;
398  BCAP_PACKET *pRecPacket;
399 
400  BCAP_HRESULT hr = BCAP_E_FAIL;
401 
402  pPacket = Packet_Create(BCAP_FUNC_Service_Start); /* Service_Start */
403  if (pPacket != NULL){
404 
405  {
406  pRecPacket = Packet_Create(BCAP_S_OK); /* storing a new packet from RC */
407  if (pRecPacket != NULL){
408  hr = bCapSendAndRec(iSockFd, pPacket, pRecPacket);
409 
410  }
411  Packet_Release(pRecPacket);
412  }
413  Packet_Release(pPacket);
414  }
415 
416  return hr;
417 
418 }
419 
428 BCAP_HRESULT bCap_ServiceStop(int iSockFd){
429  BCAP_PACKET *pPacket;
430  BCAP_PACKET *pRecPacket;
431 
432  BCAP_HRESULT hr = BCAP_E_FAIL;
433 
434  pPacket = Packet_Create(BCAP_FUNC_Service_Stop); /* alloc new packet:Service_Stop */
435  if (pPacket != NULL){
436 
437  {
438  pRecPacket = Packet_Create(BCAP_S_OK); /* alloc new packet storing a packet from RC */
439  if (pRecPacket != NULL){
440  hr = bCapSendAndRec(iSockFd, pPacket, pRecPacket);
441 
442  }
443  Packet_Release(pRecPacket);
444  }
445  Packet_Release(pPacket);
446  }
447 
448  return hr;
449 
450 }
451 
452 
453 
467 BCAP_HRESULT bCap_ControllerConnect( int iSockFd,
468  char *pStrCtrlname,
469  char *pStrProvName,
470  char *pStrPcName,
471  char *pStrOption,
472  u_int *plhController){
473  BCAP_PACKET *pPacket;
474  BCAP_PACKET *pRecPacket;
475  BCAP_ARG *pArg;
476 
477  BCAP_HRESULT hr = BCAP_E_FAIL;
478 
479  pPacket = Packet_Create(BCAP_FUNC_Controller_Connect); /* Controller_Connect */
480  if (pPacket != NULL){
481 
482  u_char buff[LOCALBUFFER_SZ];
483  u_int lLen;
484 
485  {
486  lLen = copyToBSTR(buff,pStrCtrlname);
487  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
488  if (pArg != NULL){
489  Packet_AddArg(pPacket, pArg);
490  }
491  }
492  {
493  lLen = copyToBSTR(buff,pStrProvName);
494  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
495  if (pArg != NULL){
496  Packet_AddArg(pPacket, pArg);
497  }
498  }
499  {
500  lLen = copyToBSTR(buff,pStrPcName);
501  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
502  if (pArg != NULL){
503  Packet_AddArg(pPacket, pArg);
504  }
505  }
506  {
507  lLen = copyToBSTR(buff,pStrOption);
508  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
509  if (pArg != NULL){
510  Packet_AddArg(pPacket, pArg);
511  }
512  }
513 
514  {
515  pRecPacket = Packet_Create(BCAP_S_OK);
516  if (pRecPacket != NULL){
517  hr = bCapSendAndRec(iSockFd, pPacket, pRecPacket);
518  if (SUCCEEDED(hr)){
519  copyValue(plhController, pRecPacket->pArg->data, 4);
520  }
521 
522  }
523  Packet_Release(pRecPacket);
524  }
525  Packet_Release(pPacket);
526  }
527 
528  return hr;
529 
530 }
531 
532 
542 BCAP_HRESULT bCap_ControllerDisconnect(int iSockFd, u_int lhController){
543  BCAP_PACKET *pSndPacket;
544  BCAP_PACKET *pRecPacket;
545  BCAP_ARG *pArg;
546 
547  BCAP_HRESULT hr = BCAP_E_FAIL;
548 
549  pSndPacket = Packet_Create(BCAP_FUNC_Controller_Disconnect); /* Controller_Disconnect */
550  if (pSndPacket != NULL){
551 
552  {
553  pArg = Arg_Create( VT_I4, 1, 4, &lhController);
554  if (pArg != NULL){
555  Packet_AddArg(pSndPacket, pArg);
556  }
557  }
558 
559  {
560  pRecPacket = Packet_Create(BCAP_S_OK); /* storing a new packet from RC */
561  if (pRecPacket != NULL){
562  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
563 
564  }
565  Packet_Release(pRecPacket);
566  }
567  Packet_Release(pSndPacket);
568  }
569 
570  return hr;
571 
572 }
573 
574 
587 BCAP_HRESULT bCap_ControllerGetRobot(int iSockFd, u_int lhController, char *pStrRobotName, char *pStrOption, u_int *plhRobot){
588  BCAP_PACKET *pSndPacket;
589  BCAP_PACKET *pRecPacket;
590  BCAP_ARG *pArg;
591 
592  u_char buff[LOCALBUFFER_SZ];
593  u_int lLen;
594 
595  BCAP_HRESULT hr = BCAP_E_FAIL;
596 
597  pSndPacket = Packet_Create(BCAP_FUNC_Controller_GetRobot); /* BCAP_FUNC_Controller_GetRobot */
598  if (pSndPacket != NULL){
599 
600  {
601  pArg = Arg_Create( VT_I4, 1, 4, &lhController);
602  if (pArg != NULL){
603  Packet_AddArg(pSndPacket, pArg);
604  }
605  }
606  {
607  lLen = copyToBSTR(buff,pStrRobotName);
608  pArg = Arg_Create( VT_BSTR, 1, lLen, buff);
609  if (pArg != NULL){
610  Packet_AddArg(pSndPacket, pArg);
611  }
612  }
613  {
614  lLen = copyToBSTR(buff,pStrOption);
615  pArg = Arg_Create( VT_BSTR, 1, lLen, buff);
616  if (pArg != NULL){
617  Packet_AddArg(pSndPacket, pArg);
618  }
619  }
620  {
621  pRecPacket = Packet_Create(BCAP_S_OK);
622  if (pRecPacket != NULL){
623  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
624  if SUCCEEDED(hr) {
625  copyValue(plhRobot, pRecPacket->pArg->data, 4);
626  }
627  else {
628  /* NO Argument */
629  hr = BCAP_E_FAIL;
630  }
631 
632  }
633  Packet_Release(pRecPacket);
634  }
635  Packet_Release(pSndPacket);
636  }
637 
638  return hr;
639 }
640 
641 
655 BCAP_HRESULT bCap_ControllerGetVariable(int iSockFd, u_int lhController, char *pVarName, char *pstrOption, u_int *plhVar){
656  BCAP_PACKET *pSndPacket;
657  BCAP_PACKET *pRecPacket;
658  BCAP_ARG *pArg;
659 
660  BCAP_HRESULT hr = BCAP_E_FAIL;
661 
662  pSndPacket = Packet_Create(BCAP_FUNC_Controller_GetVariable); /* BCAP_FUNC_Controller_GetVariable */
663  if (pSndPacket != NULL){
664 
665  u_char buff[LOCALBUFFER_SZ];
666  u_int lLen;
667 
668  {
669  pArg = Arg_Create( VT_I4, 1, 4, &lhController);
670  if (pArg != NULL){
671  Packet_AddArg(pSndPacket, pArg);
672  }
673  }
674 
675  {
676  lLen = copyToBSTR(buff,pVarName);
677  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
678  if (pArg != NULL){
679  Packet_AddArg(pSndPacket, pArg);
680  }
681  }
682 
683  {
684  lLen = copyToBSTR(buff,pstrOption);
685  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
686  if (pArg != NULL){
687  Packet_AddArg(pSndPacket, pArg);
688  }
689  }
690 
691  {
692  pRecPacket = Packet_Create(BCAP_S_OK);
693  if (pRecPacket != NULL){
694  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
695  if SUCCEEDED(hr){
696  if (pRecPacket->iArgs >= 1){
697  copyValue(plhVar, pRecPacket->pArg->data, 4);
698  }
699  else{
700  /* NO Argument */
701  hr = BCAP_E_FAIL;
702  }
703  }
704 
705  }
706  Packet_Release(pRecPacket);
707  }
708  Packet_Release(pSndPacket);
709  }
710 
711  return hr;
712 }
713 
726 BCAP_HRESULT bCap_ControllerGetTask(int iSockFd, u_int lhController, char *pTskName, char *pstrOption, u_int *plhVar){
727  BCAP_PACKET *pSndPacket;
728  BCAP_PACKET *pRecPacket;
729  BCAP_ARG *pArg;
730 
731  BCAP_HRESULT hr = BCAP_E_FAIL;
732 
733  pSndPacket = Packet_Create(BCAP_FUNC_Controller_GetTask); /* BCAP_FUNC_Controller_GetTask */
734  if (pSndPacket != NULL){
735 
736  u_char buff[LOCALBUFFER_SZ];
737  u_int lLen;
738 
739  {
740  pArg = Arg_Create( VT_I4, 1, 4, &lhController);
741  if (pArg != NULL){
742  Packet_AddArg(pSndPacket, pArg);
743  }
744  }
745 
746  {
747  lLen = copyToBSTR(buff,pTskName);
748  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
749  if (pArg != NULL){
750  Packet_AddArg(pSndPacket, pArg);
751  }
752  }
753 
754  {
755  lLen = copyToBSTR(buff, pstrOption);
756  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
757  if (pArg != NULL){
758  Packet_AddArg(pSndPacket, pArg);
759  }
760  }
761 
762  {
763  pRecPacket = Packet_Create(BCAP_S_OK);
764  if (pRecPacket != NULL){
765  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
766  if SUCCEEDED(hr){
767  if (pRecPacket->iArgs >= 1){
768  copyValue(plhVar, pRecPacket->pArg->data, 4);
769  }
770  else{
771  /* NO Argument */
772  hr = BCAP_E_FAIL;
773  }
774  }
775 
776  }
777  Packet_Release(pRecPacket);
778  }
779  Packet_Release(pSndPacket);
780  }
781 
782  return hr;
783 }
784 
785 
800 BCAP_HRESULT bCap_ControllerExecute(int iSockFd, u_int lhController, char *pStrCommand, char *pStrOption, void *pResult){
801  BCAP_PACKET *pSndPacket;
802  BCAP_PACKET *pRecPacket;
803  BCAP_ARG *pArg;
804 
805  BCAP_HRESULT hr = BCAP_E_FAIL;
806 
807  pSndPacket = Packet_Create(BCAP_FUNC_Controller_Execute); /* BCAP_FUNC_Controller_Execute */
808  if (pSndPacket != NULL){
809 
810  u_char buff[LOCALBUFFER_SZ];
811  u_int lLen;
812 
813  {
814  pArg = Arg_Create( VT_I4, 1, 4, &lhController);
815  if (pArg != NULL){
816  Packet_AddArg(pSndPacket, pArg);
817  }
818  }
819 
820  {
821  lLen = copyToBSTR(buff,pStrCommand);
822  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
823  if (pArg != NULL){
824  Packet_AddArg(pSndPacket, pArg);
825  }
826  }
827 
828  {
829  lLen = copyToBSTR(buff, pStrOption);
830  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
831  if (pArg != NULL){
832  Packet_AddArg(pSndPacket, pArg);
833  }
834  }
835 
836  {
837  pRecPacket = Packet_Create(BCAP_S_OK);
838  if (pRecPacket != NULL){
839  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
840  if SUCCEEDED(hr){
841  hr = Packet_GetResult(pRecPacket, pResult);
842  }
843 
844  }
845  Packet_Release(pRecPacket);
846  }
847  Packet_Release(pSndPacket);
848  }
849 
850  return hr;
851 }
852 
853 
867 BCAP_HRESULT bCap_ControllerExecute2(int iSockFd, u_int lhController, char *pStrCommand, BCAP_VARIANT *pVntOption, BCAP_VARIANT *pVntResult){
868  BCAP_PACKET *pSndPacket;
869  BCAP_PACKET *pRecPacket;
870  BCAP_ARG *pArg;
871 
872  BCAP_HRESULT hr = BCAP_E_FAIL;
873 
874  pSndPacket = Packet_Create(BCAP_FUNC_Controller_Execute); /* BCAP_FUNC_Controller_Execute */
875  if (pSndPacket != NULL){
876 
877  u_char buff[LOCALBUFFER_SZ];
878  u_int lLen;
879 
880  {
881  pArg = Arg_Create( VT_I4, 1, 4, &lhController);
882  if (pArg != NULL){
883  Packet_AddArg(pSndPacket, pArg);
884  }
885  }
886 
887  {
888  lLen = copyToBSTR(buff,pStrCommand);
889  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
890  if (pArg != NULL){
891  Packet_AddArg(pSndPacket, pArg);
892  }
893  }
894 
895  if (pVntOption != NULL){
896  u_int lSize;
897  lSize = sizeOfVariant(*pVntOption);
898  //if (lSize >= 0){ //always true
899  pArg = Arg_Create( pVntOption->Type, pVntOption->Arrays, lSize, &(pVntOption->Value));
900  if (pArg != NULL){
901  Packet_AddArg(pSndPacket, pArg);
902  }
903  //}
904  }
905 
906  {
907  pRecPacket = Packet_Create(BCAP_S_OK);
908  if (pRecPacket != NULL){
909  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
910  if SUCCEEDED(hr){
911  if (pRecPacket->iArgs >= 1){
912  // copyValue(plResult, pRecPacket->pArg->data, 4);
913  copyVariantFromArg(pVntResult, pRecPacket->pArg);
914  // copyArgValue(plResult, pRecPacket->pArg);
915  }
916  }
917 
918  }
919  Packet_Release(pRecPacket);
920  }
921  Packet_Release(pSndPacket);
922  }
923 
924  return hr;
925 }
926 
936 BCAP_HRESULT bCap_RobotRelease(int iSockFd, u_int lhRobot){
937  BCAP_PACKET *pSndPacket;
938  BCAP_PACKET *pRecPacket;
939  BCAP_ARG *pArg;
940 
941 
942  BCAP_HRESULT hr = BCAP_E_FAIL;
943 
944  pSndPacket = Packet_Create(BCAP_FUNC_Robot_Release); /* FuncID:RobotRelease */
945  if (pSndPacket != NULL){
946 
947  {
948  pArg = Arg_Create( VT_I4, 1, 4, &lhRobot);
949  if (pArg != NULL){
950  Packet_AddArg(pSndPacket, pArg); /* Add 1st argument */
951  }
952  }
953 
954  {
955  pRecPacket = Packet_Create(BCAP_S_OK); /* Alloc for storing received packet */
956  if (pRecPacket != NULL){
957  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
958 
959  }
960  Packet_Release(pRecPacket); /* Release recieved packet */
961  }
962  Packet_Release(pSndPacket);
963  }
964 
965  return hr;
966 }
967 
968 
969 
982 BCAP_HRESULT bCap_RobotGetVariable(int iSockFd, u_int lhRobot, char *pVarName, char *pstrOption, u_int *plhVar){
983  BCAP_PACKET *pSndPacket;
984  BCAP_PACKET *pRecPacket;
985  BCAP_ARG *pArg;
986 
987  BCAP_HRESULT hr = BCAP_E_FAIL;
988 
989  pSndPacket = Packet_Create(BCAP_FUNC_Robot_GetVariable); /* BCAP_FUNC_Robot_GetVariable */
990  if (pSndPacket != NULL){
991 
992  u_char buff[LOCALBUFFER_SZ];
993  u_int lLen;
994 
995  {
996  pArg = Arg_Create( VT_I4, 1, 4, &lhRobot);
997  if (pArg != NULL){
998  Packet_AddArg(pSndPacket, pArg);
999  }
1000  }
1001 
1002  {
1003  lLen = copyToBSTR(buff,pVarName);
1004  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
1005  if (pArg != NULL){
1006  Packet_AddArg(pSndPacket, pArg);
1007  }
1008  }
1009 
1010  {
1011  lLen = copyToBSTR(buff, pstrOption);
1012  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
1013  if (pArg != NULL){
1014  Packet_AddArg(pSndPacket, pArg);
1015  }
1016  }
1017 
1018  {
1019  pRecPacket = Packet_Create(BCAP_S_OK);
1020  if (pRecPacket != NULL){
1021  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1022  if SUCCEEDED(hr){
1023  if (pRecPacket->iArgs >= 1){
1024  copyValue(plhVar, pRecPacket->pArg->data, 4);
1025  }
1026  else{
1027 
1028  }
1029  }
1030  }
1031  Packet_Release(pRecPacket);
1032  }
1033  Packet_Release(pSndPacket);
1034  }
1035 
1036  return hr;
1037 }
1038 
1039 
1054 BCAP_HRESULT bCap_RobotExecute(int iSockFd, u_int lhRobot, char *pStrCommand, char *pStrOption, void *pResult){
1055  BCAP_PACKET *pSndPacket;
1056  BCAP_PACKET *pRecPacket;
1057  BCAP_ARG *pArg;
1058 
1059  BCAP_HRESULT hr = BCAP_E_FAIL;
1060 
1061  pSndPacket = Packet_Create(BCAP_FUNC_Robot_Execute); /* BCAP_FUNC_Robot_Execute */
1062  if (pSndPacket != NULL){
1063 
1064  u_char buff[LOCALBUFFER_SZ];
1065  u_int lLen;
1066 
1067  {
1068  pArg = Arg_Create( VT_I4, 1, 4, &lhRobot);
1069  if (pArg != NULL){
1070  Packet_AddArg(pSndPacket, pArg);
1071  }
1072  }
1073 
1074  {
1075  lLen = copyToBSTR(buff,pStrCommand);
1076  pArg = Arg_Create( VT_BSTR, 1, lLen, buff);
1077  if (pArg != NULL){
1078  Packet_AddArg(pSndPacket, pArg);
1079  }
1080  }
1081 
1082  {
1083  lLen = copyToBSTR(buff, pStrOption);
1084  pArg = Arg_Create( VT_BSTR, 1, lLen, buff);
1085  if (pArg != NULL){
1086  Packet_AddArg(pSndPacket, pArg);
1087  }
1088  }
1089 
1090  {
1091  pRecPacket = Packet_Create(BCAP_S_OK);
1092  if (pRecPacket != NULL){
1093  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1094  if SUCCEEDED(hr){
1095  hr = Packet_GetResult(pRecPacket, pResult);
1096  }
1097 
1098  }
1099  Packet_Release(pRecPacket);
1100  }
1101  Packet_Release(pSndPacket);
1102  }
1103 
1104  return hr;
1105 }
1106 
1107 
1121 BCAP_HRESULT bCap_RobotExecute2(int iSockFd, u_int lhRobot, char *pStrCommand, BCAP_VARIANT *pVntOption, BCAP_VARIANT *pVntResult){
1122  BCAP_PACKET *pSndPacket;
1123  BCAP_PACKET *pRecPacket;
1124  BCAP_ARG *pArg;
1125 
1126  BCAP_HRESULT hr = BCAP_E_FAIL;
1127 
1128  pSndPacket = Packet_Create(BCAP_FUNC_Robot_Execute); /* BCAP_FUNC_Controller_Execute */
1129  if (pSndPacket != NULL){
1130 
1131  u_char buff[LOCALBUFFER_SZ];
1132  u_int lLen;
1133 
1134  {
1135  pArg = Arg_Create( VT_I4, 1, 4, &lhRobot);
1136  if (pArg != NULL){
1137  Packet_AddArg(pSndPacket, pArg);
1138  }
1139  }
1140 
1141  {
1142  lLen = copyToBSTR(buff,pStrCommand);
1143  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
1144  if (pArg != NULL){
1145  Packet_AddArg(pSndPacket, pArg);
1146  }
1147  }
1148 
1149  if (pVntOption != NULL){
1150  u_int lSize;
1151  lSize = sizeOfVariant(*pVntOption);
1152  //if (lSize >= 0){
1153  pArg = Arg_Create( pVntOption->Type, pVntOption->Arrays, lSize, &(pVntOption->Value));
1154  if (pArg != NULL){
1155  Packet_AddArg(pSndPacket, pArg);
1156  }
1157  //}
1158  }
1159 
1160  {
1161  pRecPacket = Packet_Create(BCAP_S_OK);
1162  if (pRecPacket != NULL){
1163  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1164  if SUCCEEDED(hr){
1165  if (pRecPacket->iArgs >= 1){
1166  // copyValue(plResult, pRecPacket->pArg->data, 4);
1167  copyVariantFromArg(pVntResult, pRecPacket->pArg);
1168  // copyArgValue(plResult, pRecPacket->pArg);
1169  }
1170 
1171  }
1172 
1173  }
1174  Packet_Release(pRecPacket);
1175  }
1176  Packet_Release(pSndPacket);
1177  }
1178 
1179  return hr;
1180 }
1181 
1194 BCAP_HRESULT bCap_RobotChange(int iSockFd, u_int lhRobot, char *pStrCommand){
1195  BCAP_PACKET *pSndPacket;
1196  BCAP_PACKET *pRecPacket;
1197  BCAP_ARG *pArg;
1198 
1199  BCAP_HRESULT hr = BCAP_E_FAIL;
1200 
1201  pSndPacket = Packet_Create(BCAP_FUNC_Robot_Change); /* BCAP_FUNC_Robot_Change */
1202  if (pSndPacket != NULL){
1203 
1204  u_char buff[LOCALBUFFER_SZ];
1205  u_int lLen;
1206 
1207  {
1208  pArg = Arg_Create( VT_I4, 1, 4, &lhRobot);
1209  if (pArg != NULL){
1210  Packet_AddArg(pSndPacket, pArg);
1211  }
1212  }
1213 
1214  {
1215  lLen = copyToBSTR(buff,pStrCommand);
1216  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
1217  if (pArg != NULL){
1218  Packet_AddArg(pSndPacket, pArg);
1219  }
1220  }
1221 
1222  {
1223  pRecPacket = Packet_Create(BCAP_S_OK);
1224  if (pRecPacket != NULL){
1225  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1226  if SUCCEEDED(hr){
1227  ;
1228  }
1229 
1230  }
1231  Packet_Release(pRecPacket);
1232  }
1233  Packet_Release(pSndPacket);
1234  }
1235 
1236  return hr;
1237 }
1238 
1239 
1252 BCAP_HRESULT bCap_RobotMove(int iSockFd, u_int lhRobot, long lComp, char *pStrPose, char *pStrOption){
1253  BCAP_PACKET *pSndPacket;
1254  BCAP_PACKET *pRecPacket;
1255  BCAP_ARG *pArg;
1256 
1257  BCAP_HRESULT hr = BCAP_E_FAIL;
1258 
1259  pSndPacket = Packet_Create(BCAP_FUNC_Robot_Move); /* BCAP_FUNC_Robot_Move */
1260  if (pSndPacket != NULL){
1261 
1262  u_char buff[LOCALBUFFER_SZ];
1263  u_int lLen;
1264 
1265  {
1266  pArg = Arg_Create( VT_I4, 1, 4, &lhRobot); /* Arg1 Handle of the robot */
1267  if (pArg != NULL){
1268  Packet_AddArg(pSndPacket, pArg);
1269  }
1270  }
1271 
1272  {
1273  pArg = Arg_Create( VT_I4, 1, 4, &lComp); /* Arg2 Completion param */
1274  if (pArg != NULL){
1275  Packet_AddArg(pSndPacket, pArg);
1276  }
1277  }
1278 
1279  {
1280  lLen = copyToBSTR(buff,pStrPose); /* Arg3 Pose param */
1281  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
1282  if (pArg != NULL){
1283  Packet_AddArg(pSndPacket, pArg);
1284  }
1285  }
1286 
1287  {
1288  lLen = copyToBSTR(buff,pStrOption); /* Arg4 option param */
1289  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
1290  if (pArg != NULL){
1291  Packet_AddArg(pSndPacket, pArg);
1292  }
1293  }
1294 
1295 
1296  {
1297  pRecPacket = Packet_Create(BCAP_S_OK);
1298  if (pRecPacket != NULL){
1299  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1300  if SUCCEEDED(hr){
1301  ;
1302  }
1303 
1304  }
1305  Packet_Release(pRecPacket);
1306  }
1307  Packet_Release(pSndPacket);
1308  }
1309 
1310  return hr;
1311 }
1312 
1327 BCAP_HRESULT bCap_RobotExecuteSlaveMove(int iSockFd, u_int lhRobot, char *pStrCommand, float *pfOption, void *pResult){
1328  BCAP_PACKET *pSndPacket;
1329  BCAP_PACKET *pRecPacket;
1330  BCAP_ARG *pArg;
1331 
1332  BCAP_HRESULT hr = BCAP_E_FAIL;
1333 
1334  pSndPacket = Packet_Create(BCAP_FUNC_Robot_Execute); /* BCAP_FUNC_Robot_Execute */
1335  if (pSndPacket != NULL){
1336 
1337  u_char buff[LOCALBUFFER_SZ];
1338  u_int lLen;
1339 
1340  {
1341  pArg = Arg_Create( VT_I4, 1, 4, &lhRobot);
1342  if (pArg != NULL){
1343  Packet_AddArg(pSndPacket, pArg);
1344  }
1345  }
1346 
1347  {
1348  lLen = copyToBSTR(buff,pStrCommand);
1349  pArg = Arg_Create( VT_BSTR, 1, lLen, buff);
1350  if (pArg != NULL){
1351  Packet_AddArg(pSndPacket, pArg);
1352  }
1353  }
1354 
1355  { /* R4”z—ñ‚ňʒu‚ðŽw’è */
1356  pArg = Arg_Create( VT_R4 | VT_ARRAY, 8, sizeof(float) * 8, pfOption); /* 8Ž²‚Ô‚ñ */
1357  if (pArg != NULL){
1358  Packet_AddArg(pSndPacket, pArg);
1359  }
1360  }
1361 
1362  {
1363  pRecPacket = Packet_Create(BCAP_S_OK);
1364  if (pRecPacket != NULL){
1365  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1366  if SUCCEEDED(hr){
1367  hr = Packet_GetResult(pRecPacket, pResult);
1368  }
1369 
1370  }
1371  Packet_Release(pRecPacket);
1372  }
1373  Packet_Release(pSndPacket);
1374  }
1375 
1376  return hr;
1377 }
1378 
1379 
1389 BCAP_HRESULT bCap_TaskRelease(int iSockFd, u_int lhTask){
1390  BCAP_PACKET *pSndPacket;
1391  BCAP_PACKET *pRecPacket;
1392  BCAP_ARG *pArg;
1393 
1394 
1395  BCAP_HRESULT hr = BCAP_E_FAIL;
1396 
1397  pSndPacket = Packet_Create(BCAP_FUNC_Task_Release); /* BCAP_FUNC_Task_Release */
1398  if (pSndPacket != NULL){
1399 
1400  {
1401  pArg = Arg_Create( VT_I4, 1, 4, &lhTask);
1402  if (pArg != NULL){
1403  Packet_AddArg(pSndPacket, pArg); /* Arg1 lhTask */
1404  }
1405  }
1406 
1407  {
1408  pRecPacket = Packet_Create(BCAP_S_OK); /* Alloc for storing recieved packet */
1409  if (pRecPacket != NULL){
1410  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1411 
1412  }
1413  Packet_Release(pRecPacket); /* Release recieved packet */
1414  }
1415  Packet_Release(pSndPacket);
1416  }
1417 
1418  return hr;
1419 }
1420 
1421 
1434 BCAP_HRESULT bCap_TaskGetVariable(int iSockFd, u_int lhTask, char *pVarName, char *pstrOption, u_int *plhVar){
1435  BCAP_PACKET *pSndPacket;
1436  BCAP_PACKET *pRecPacket;
1437  BCAP_ARG *pArg;
1438 
1439  BCAP_HRESULT hr = BCAP_E_FAIL;
1440 
1441  pSndPacket = Packet_Create(BCAP_FUNC_Task_GetVariable); /* BCAP_FUNC_Task_GetVariable */
1442  if (pSndPacket != NULL){
1443 
1444  u_char buff[LOCALBUFFER_SZ];
1445  u_int lLen;
1446 
1447  {
1448  pArg = Arg_Create( VT_I4, 1, 4, &lhTask);
1449  if (pArg != NULL){
1450  Packet_AddArg(pSndPacket, pArg);
1451  }
1452  }
1453 
1454  {
1455  lLen = copyToBSTR(buff,pVarName);
1456  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
1457  if (pArg != NULL){
1458  Packet_AddArg(pSndPacket, pArg);
1459  }
1460  }
1461 
1462  {
1463  lLen = copyToBSTR(buff, pstrOption);
1464  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
1465  if (pArg != NULL){
1466  Packet_AddArg(pSndPacket, pArg);
1467  }
1468  }
1469 
1470  {
1471  pRecPacket = Packet_Create(BCAP_S_OK);
1472  if (pRecPacket != NULL){
1473  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1474  if SUCCEEDED(hr){
1475  if (pRecPacket->iArgs >= 1){
1476  copyValue(plhVar, pRecPacket->pArg->data, 4);
1477  }
1478  else{
1479 
1480  }
1481  }
1482  }
1483  Packet_Release(pRecPacket);
1484  }
1485  Packet_Release(pSndPacket);
1486  }
1487 
1488  return hr;
1489 }
1490 
1491 
1503 BCAP_HRESULT bCap_TaskStart(int iSockFd, u_int lhTask, long lMode, char *pStrOption){
1504  BCAP_PACKET *pSndPacket;
1505  BCAP_PACKET *pRecPacket;
1506  BCAP_ARG *pArg;
1507 
1508  BCAP_HRESULT hr = BCAP_E_FAIL;
1509 
1510  pSndPacket = Packet_Create(BCAP_FUNC_Task_Start); /* BCAP_FUNC_Task_Start */
1511  if (pSndPacket != NULL){
1512 
1513  u_char buff[LOCALBUFFER_SZ];
1514  u_int lLen;
1515 
1516  {
1517  pArg = Arg_Create( VT_I4, 1, 4, &lhTask); /* Arg1 Handle of the task */
1518  if (pArg != NULL){
1519  Packet_AddArg(pSndPacket, pArg);
1520  }
1521  }
1522 
1523  {
1524  pArg = Arg_Create( VT_I4, 1, 4, &lMode); /* Arg2 start param */
1525  if (pArg != NULL){
1526  Packet_AddArg(pSndPacket, pArg);
1527  }
1528  }
1529 
1530 
1531  {
1532  lLen = copyToBSTR(buff,pStrOption); /* Arg3 option param */
1533  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
1534  if (pArg != NULL){
1535  Packet_AddArg(pSndPacket, pArg);
1536  }
1537  }
1538 
1539 
1540  {
1541  pRecPacket = Packet_Create(BCAP_S_OK);
1542  if (pRecPacket != NULL){
1543  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1544  if SUCCEEDED(hr){
1545  ;
1546  }
1547 
1548  }
1549  Packet_Release(pRecPacket);
1550  }
1551  Packet_Release(pSndPacket);
1552  }
1553 
1554  return hr;
1555 }
1556 
1557 
1569 BCAP_HRESULT bCap_TaskStop(int iSockFd, u_int lhTask, long lMode, char *pStrOption){
1570  BCAP_PACKET *pSndPacket;
1571  BCAP_PACKET *pRecPacket;
1572  BCAP_ARG *pArg;
1573 
1574  BCAP_HRESULT hr = BCAP_E_FAIL;
1575 
1576  pSndPacket = Packet_Create(BCAP_FUNC_Task_Stop); /* BCAP_FUNC_Task_Stop */
1577  if (pSndPacket != NULL){
1578 
1579  u_char buff[LOCALBUFFER_SZ];
1580  u_int lLen;
1581 
1582  {
1583  pArg = Arg_Create( VT_I4, 1, 4, &lhTask); /* Arg1 Handle of the task */
1584  if (pArg != NULL){
1585  Packet_AddArg(pSndPacket, pArg);
1586  }
1587  }
1588 
1589  {
1590  pArg = Arg_Create( VT_I4, 1, 4, &lMode); /* Arg2 stop param */
1591  if (pArg != NULL){
1592  Packet_AddArg(pSndPacket, pArg);
1593  }
1594  }
1595 
1596 
1597  {
1598  lLen = copyToBSTR(buff,pStrOption); /* Arg3 option param */
1599  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
1600  if (pArg != NULL){
1601  Packet_AddArg(pSndPacket, pArg);
1602  }
1603  }
1604 
1605 
1606  {
1607  pRecPacket = Packet_Create(BCAP_S_OK);
1608  if (pRecPacket != NULL){
1609  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1610  if SUCCEEDED(hr){
1611  ;
1612  }
1613 
1614  }
1615  Packet_Release(pRecPacket);
1616  }
1617  Packet_Release(pSndPacket);
1618  }
1619 
1620  return hr;
1621 }
1622 
1623 
1633 BCAP_HRESULT bCap_VariableRelease(int iSockFd, u_int lhVar){
1634  BCAP_PACKET *pSndPacket;
1635  BCAP_PACKET *pRecPacket;
1636  BCAP_ARG *pArg;
1637 
1638 
1639  BCAP_HRESULT hr = BCAP_E_FAIL;
1640 
1641  pSndPacket = Packet_Create(BCAP_FUNC_Variable_Release); /* BCAP_FUNC_Task_Release */
1642  if (pSndPacket != NULL){
1643 
1644  {
1645  pArg = Arg_Create( VT_I4, 1, 4, &lhVar);
1646  if (pArg != NULL){
1647  Packet_AddArg(pSndPacket, pArg); /* Arg1 lhVariable */
1648  }
1649  }
1650 
1651  {
1652  pRecPacket = Packet_Create(BCAP_S_OK); /* Alloc for storing recieved packet */
1653  if (pRecPacket != NULL){
1654  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1655 
1656  }
1657  Packet_Release(pRecPacket); /* Release recieved packet */
1658  }
1659  Packet_Release(pSndPacket);
1660  }
1661 
1662  return hr;
1663 }
1664 
1676 BCAP_HRESULT bCap_VariableGetValue(int iSockFd, u_int lhVar, void *pVntValue){
1677  BCAP_PACKET *pSndPacket;
1678  BCAP_PACKET *pRecPacket;
1679  BCAP_ARG *pArg;
1680 
1681  BCAP_HRESULT hr = BCAP_E_FAIL;
1682 
1683  pSndPacket = Packet_Create(BCAP_FUNC_Variable_GetValue); /* BCAP_FUNC_Variable_GetValue */
1684  if (pSndPacket != NULL){
1685 
1686  {
1687  pArg = Arg_Create( VT_I4, 1, 4, &lhVar); /* Arg1: Variable handle */
1688  if (pArg != NULL){
1689  Packet_AddArg(pSndPacket, pArg);
1690  }
1691  }
1692 
1693  {
1694  pRecPacket = Packet_Create(BCAP_S_OK);
1695  if (pRecPacket != NULL){
1696  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1697  if SUCCEEDED(hr){
1698  if (pRecPacket->iArgs >= 1){
1699  hr = Packet_GetResult(pRecPacket, pVntValue);
1700  }
1701  else{
1702  /* NO Argument */
1703  hr = BCAP_E_FAIL;
1704  }
1705  }
1706 
1707  }
1708  Packet_Release(pRecPacket);
1709  }
1710  Packet_Release(pSndPacket);
1711  }
1712 
1713  return hr;
1714 }
1715 
1727 BCAP_HRESULT bCap_VariablePutValue(int iSockFd, u_int lhVar, u_short iType, u_int lArrays, void *pVntValue){
1728  BCAP_PACKET *pSndPacket;
1729  BCAP_PACKET *pRecPacket;
1730  BCAP_ARG *pArg;
1731 
1732  BCAP_HRESULT hr = BCAP_E_FAIL;
1733 
1734  pSndPacket = Packet_Create(BCAP_FUNC_Variable_PutValue); /* BCAP_FUNC_Variable_PutValue */
1735  if (pSndPacket != NULL){
1736 
1737  {
1738  pArg = Arg_Create( VT_I4, 1, 4, &lhVar);
1739  if (pArg != NULL){
1740  Packet_AddArg(pSndPacket, pArg);
1741  }
1742  }
1743 
1744  {
1745  u_int lDataLen = 0;
1746 
1747  if ((iType & ~VT_ARRAY) == VT_BSTR) { /* Mask "Array" */ /* IMPL:Not Support String array now. */
1748  /* String data */
1749 
1750  u_char buff[LOCALBUFFER_SZ];
1751  u_int lLen;
1752 
1753  lLen = copyToBSTR(buff,pVntValue);
1754  pArg = Arg_Create( VT_BSTR, 1, lLen,buff);
1755  if (pArg != NULL){
1756  Packet_AddArg(pSndPacket, pArg);
1757  }
1758  }
1759  else{
1760  /* Not string data */
1761 
1762  u_int lLen;
1763  lLen = sizeOfVarType((u_short)(iType & ~VT_ARRAY));
1764  lDataLen = lLen * lArrays;
1765  if (lDataLen != 0){
1766  u_int i;
1767  u_char *pSrcData = (u_char *)pVntValue;
1768  u_char *pDstData = (u_char *)bMalloc(lDataLen);
1769  if (pDstData != NULL){
1770  u_char *pDstPtr = pDstData;
1771  for (i = 0;i < lArrays;i++){
1772 
1773  copyValue(pDstPtr, pSrcData, lLen);
1774  pDstPtr += lLen;
1775  pSrcData += lLen;
1776  }
1777 
1778  pArg = Arg_Create( iType, lArrays, lDataLen, pDstData);
1779  if (pArg != NULL){
1780  Packet_AddArg(pSndPacket, pArg);
1781  }
1782  bFree(pDstData);
1783  }
1784  }
1785  else{ /* lDataLen = 0,then Unknown data type */
1786  Packet_Release(pSndPacket);
1787  return (BCAP_E_INVALIDARGTYPE);
1788  }
1789  }
1790  }
1791 
1792 
1793  {
1794  pRecPacket = Packet_Create(BCAP_S_OK);
1795  if (pRecPacket != NULL){
1796  hr = bCapSendAndRec(iSockFd, pSndPacket, pRecPacket);
1797  if SUCCEEDED(hr){
1798  ;
1799  }
1800 
1801  }
1802  Packet_Release(pRecPacket);
1803  }
1804  Packet_Release(pSndPacket);
1805  }
1806 
1807  return hr;
1808 }
1809 
1810 /*--------------------------------------------------------------------
1811  b-Cap library utility functions
1812  --------------------------------------------------------------------*/
1813 
1814 
1824 int failed_to_send_packet = 0;
1825 static BCAP_HRESULT bCapSendAndRec(int iSockFd, BCAP_PACKET *pSndPacket, BCAP_PACKET *pRecPacket){
1826  failed_to_send_packet = 0;
1827  BCAP_HRESULT hr = BCAP_E_FAIL;
1828  int retry_count = 0;
1829 StartPoint:
1830  if ( (pRecPacket != NULL) && (pSndPacket != NULL) ){
1831  struct timespec prev_time;
1832  clock_gettime(CLOCK_MONOTONIC, &prev_time);
1833  if (Packet_Send(iSockFd, pSndPacket) == BCAP_S_OK){
1834  struct timespec send_after_time;
1835  clock_gettime(CLOCK_MONOTONIC, &send_after_time);
1836  int retryp = 0;
1837  u_char *pRec = receivePacket(iSockFd, &retryp); /* Receive packet and alloc memory for storing received binary */
1838  struct timespec recv_after_time;
1839  clock_gettime(CLOCK_MONOTONIC, &recv_after_time);
1840  const int NSEC_PER_SECOND = 1e+9;
1841  //fprintf(stderr, "send time: %f\n", (send_after_time.tv_sec + double(send_after_time.tv_nsec)/NSEC_PER_SECOND)- (prev_time.tv_sec + double(prev_time.tv_nsec)/NSEC_PER_SECOND) );
1842  //fprintf(stderr, "recv time: %f\n", (recv_after_time.tv_sec + double(recv_after_time.tv_nsec)/NSEC_PER_SECOND) - (send_after_time.tv_sec + double(send_after_time.tv_nsec)/NSEC_PER_SECOND));
1843  if (retryp) {
1844  failed_to_send_packet = 1;
1845  ++retry_count;
1846  //fprintf(stderr, "should retry %u (%d)", pSndPacket->iSerialNo, retry_count);
1847  pSndPacket->iReserved = pSndPacket->iSerialNo;
1848  pSndPacket->iSerialNo = ++m_iSerialNo;
1849 
1850  /* struct timeval tv; */
1851  /* tv.tv_sec = 0; */
1852  /* tv.tv_usec = 1000 * 100; /\* 100msec *\/ */
1853  /* setsockopt(iSockFd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); */
1854  goto StartPoint;
1855  }
1856  else if(pRec != NULL){
1857  hr = Packet_Deserialize(pRec, pRecPacket );
1858  if SUCCEEDED(hr){
1859  hr = (BCAP_HRESULT)pRecPacket->lFuncID;
1860  }
1861  bFree(pRec); /* Free received packet */
1862  }
1863  else{
1864  /* allocation error */
1865  hr = BCAP_E_UNEXPECTED;
1866  }
1867  }
1868  else{
1869  /* send error */
1870  hr = BCAP_E_UNEXPECTED;
1871  }
1872  }
1873  else{
1874  /* Null pointer is asigned */
1875  hr = BCAP_E_FAIL;
1876  }
1877 
1878  return hr;
1879 
1880 }
1881 
1882 
1893 static u_char *receivePacket(int iSockFd, int* retryp){
1894  u_char pRcvBuffer[LOCALRECBUFFER_SZ];
1895  u_char *pTop;
1896  u_char *pPacketBuff = NULL;
1897  u_char *pRemainData;
1898 
1899  u_int lRecvSize;
1900  int lRecLen;
1901  u_int lHeaderLen;
1902 
1903 #ifdef BCAP_CONNECTION_UDP
1904  socklen_t fromlen;
1905  struct sockaddr_in serverAddr; /* server's socket address */
1906 #endif
1907 
1908  /* b-CAP header = 15 bytes, this should be recieved at first */
1909  lHeaderLen = BCAP_SIZE_SOH + BCAP_SIZE_LEN +
1910  BCAP_SIZE_SERIAL + BCAP_SIZE_RESERVE +
1911  BCAP_SIZE_FUNCID + BCAP_SIZE_ARGNUM;
1912 
1913  /* Receive b-Cap header */
1914  lRecvSize = 0;
1915  while (lRecvSize < lHeaderLen) {
1916 #if BCAP_CONNECTION_COM /* COM */
1917 #ifdef WIN32
1918  ReadFile((HANDLE)iSockFd, (char *)&(pRcvBuffer[lRecvSize]), lHeaderLen - lRecvSize, (LPDWORD)&lRecLen, NULL);
1919 #else
1920  lRecLen = read(iSockFd, (char *)&(pRcvBuffer[lRecvSize]), lHeaderLen - lRecvSize);
1921 #endif
1922 #else
1923 #ifdef BCAP_CONNECTION_UDP
1924  fromlen = sizeof(serverAddr);
1925  memset( (char *)&serverAddr, 0, sizeof(struct sockaddr_in));
1926  *retryp = 0;
1927  lRecLen = recvfrom(iSockFd, (char *)&(pRcvBuffer[lRecvSize]), LOCALRECBUFFER_SZ - lRecvSize, 0, (struct sockaddr *)&serverAddr, &fromlen);
1928  /* if the sock is not from the server, then ignore */
1929  if(lRecLen <= 0) { /* if sock errer has detected, then exit */
1930  //fprintf(stderr, "failed to receive a packet\n");
1931  *retryp = 1;
1932  goto ExitPoint;
1933  }
1934  if ((serverAddr.sin_addr.s_addr != m_sockServerAddr.sin_addr.s_addr) || (serverAddr.sin_port != m_sockServerAddr.sin_port)) {
1935  continue;
1936  }
1937 #else /* TCP */
1938  lRecLen = recv(iSockFd, (char *)&(pRcvBuffer[lRecvSize]), lHeaderLen - lRecvSize, 0);
1939 #endif
1940 #endif
1941  if(lRecLen <= 0) { /* if sock errer has detected, then exit */
1942  goto ExitPoint;
1943  }
1944  lRecvSize += lRecLen; /* add read bytes */
1945 
1946  pTop = (u_char *)memchr((const void *)pRcvBuffer, BCAP_SOH, lRecvSize);
1947  if (pTop == NULL){ /* Is there SOH ? */
1948  lRecvSize = 0; /* If No SOH, then all read data are discarded */
1949  }
1950  else{
1951  if (pTop != pRcvBuffer){ /* if (pTop == pRcvBuffer) then SOH is already in the top. */
1952  lRecvSize = lRecvSize - (pTop - pRcvBuffer); /* exclude before SOH */
1953  memmove (pRcvBuffer, pTop, lRecvSize);
1954  }
1955  }
1956  }
1957 
1958  /* Receive the left data of this packet */
1959  {
1960  u_int lPacketSize;
1961  u_int lRemainSize;
1962 
1963  copyValue(&lPacketSize, &(pRcvBuffer[1]), BCAP_SIZE_LEN);
1964  lRemainSize = lPacketSize - lRecvSize;
1965 
1966  pPacketBuff = (unsigned char *)bMalloc(lPacketSize);
1967  if (pPacketBuff != NULL){
1968  memcpy(pPacketBuff, pRcvBuffer, lRecvSize);
1969  pRemainData = pPacketBuff + lRecvSize;
1970  }
1971  else{
1972  goto ExitPoint; /* out of memory */
1973  }
1974 
1975  lRecvSize = 0;
1976  while (lRecvSize < lRemainSize) {
1977 #if BCAP_CONNECTION_COM /* COM */
1978 
1979 #ifdef WIN32
1980  ReadFile((HANDLE)iSockFd, (char *)&(pRemainData[lRecvSize]), lRemainSize - lRecvSize, (LPDWORD)&lRecLen, NULL);
1981 #else
1982  lRecLen = read(iSockFd, (char *)&(pRcvBuffer[lRecvSize]), lHeaderLen - lRecvSize);
1983 #endif
1984 
1985 #else
1986 #ifdef BCAP_CONNECTION_UDP
1987  fromlen = sizeof(serverAddr);
1988  lRecLen = recvfrom(iSockFd, (char *)&(pRemainData[lRecvSize]), lRemainSize -lRecvSize , 0, (struct sockaddr *)&serverAddr, &fromlen);
1989  /* if the sock is not from the server, then ignore */
1990  if ((serverAddr.sin_addr.s_addr != m_sockServerAddr.sin_addr.s_addr) || (serverAddr.sin_port != m_sockServerAddr.sin_port)) {
1991  continue;
1992  }
1993 
1994 #else /* TCP */
1995  lRecLen = recv(iSockFd, (char *)&(pRemainData[lRecvSize]), lRemainSize -lRecvSize , 0);
1996 #endif
1997 #endif
1998  if(lRecLen <= 0) { /* if sock errer has detected, then exit */
1999 
2000  goto ExitPoint;
2001  }
2002  lRecvSize += lRecLen; /* add read bytes */
2003  }
2004 
2005  /* Check Terminator EOT */
2006  if (pPacketBuff[lPacketSize - 1] != BCAP_EOT) {
2007  goto ExitPoint;
2008  }
2009 
2010  }
2011 
2012  return pPacketBuff;
2013 
2014 ExitPoint:
2015  if (pPacketBuff != NULL) {
2016  free(pPacketBuff);
2017  pPacketBuff = NULL;
2018  }
2019  return NULL;
2020 
2021 }
2022 
2023 
2024 
2036  static BCAP_HRESULT sendBinary(int iSockFd, u_char *pBuff, u_int lSize){
2037 
2038  BCAP_HRESULT hr = BCAP_E_FAIL;
2039  int iLen;
2040  int iSent;
2041 
2042  iLen = (int)lSize;
2043  if (iLen > 0){
2044 
2045 #if BCAP_CONNECTION_COM /* COM */
2046 
2047 #ifdef WIN32
2048  WriteFile((HANDLE)iSockFd, pBuff, iLen, (LPDWORD)&iSent, NULL);
2049 #else
2050  iSent = write(iSockFd, pBuff, iLen);
2051 #endif
2052 
2053 #else
2054 #ifdef BCAP_CONNECTION_UDP
2055  iSent = sendto(iSockFd, (char *)pBuff, iLen, 0, (struct sockaddr *)&m_sockServerAddr, sizeof(m_sockServerAddr));
2056 #else /* TCP */
2057  iSent = send(iSockFd, (char *)pBuff, iLen, 0);
2058 #endif
2059 #endif
2060 
2061  if (iSent == iLen){
2062  hr = BCAP_S_OK;
2063  }
2064 
2065  }
2066  return hr;
2067 }
2068 
2069 
2079 static BCAP_HRESULT Packet_Send(int iSockFd, BCAP_PACKET *pPacket){
2080 
2081  BCAP_HRESULT hr = BCAP_E_FAIL;
2082 
2083  void *pbSendData;
2084 
2085  pbSendData = bMalloc(pPacket->lMsgLength);
2086  if (pbSendData != NULL){
2087  if (Packet_Serialize(pPacket, pbSendData) == BCAP_S_OK){
2088 
2089  hr = sendBinary(iSockFd, (u_char *)pbSendData, pPacket->lMsgLength); /* Send packet */
2090  if (hr == BCAP_S_OK){
2091  ;
2092  }
2093  }
2094  bFree(pbSendData);
2095  }
2096 
2097  return hr;
2098 }
2099 
2100 
2109 static BCAP_ARG **Packet_GetLastArgHandle( BCAP_PACKET *pPacket){
2110  BCAP_ARG **pLastArg = NULL;
2111  BCAP_ARG *pArg;
2112 
2113  if (pPacket != NULL){
2114 
2115  pArg = pPacket->pArg; /* set base pointer in packet struct */
2116  pLastArg = &(pPacket->pArg); /* if this is NULL in this time, this packet has no argment.
2117  So, pPacket->pArg is set as the last arg. */
2118 
2119  /* search the last arg pointer */
2120  while(pArg != NULL){
2121  pLastArg = &(pArg->pNextArg);
2122 
2123  pArg = pArg->pNextArg; /* set next arg pointer. it might be NULL */
2124  }
2125  }
2126 
2127  if (pLastArg != NULL){
2128  return pLastArg;
2129  }
2130  else{
2131  return NULL;
2132  }
2133 }
2134 
2135 
2145 static BCAP_HRESULT Packet_AddArg( BCAP_PACKET *pPacket, BCAP_ARG *pNewArg){
2146 
2147  BCAP_HRESULT hr = BCAP_S_OK;
2148  BCAP_ARG **pLastArg = NULL;
2149 
2150  if ( (pPacket != NULL) && (pNewArg != NULL)) {
2151  pLastArg = Packet_GetLastArgHandle(pPacket); /* get a pointer of the last arg. */
2152  if (pLastArg == NULL){
2153 
2154  /* Bad pointer */
2155  hr = BCAP_E_FAIL;
2156  }
2157  else{
2158  /* Not NULL: then success to find the last arg */
2159  *pLastArg = pNewArg; /* Set the new arg pointer as the next arg pointer */
2160  }
2161 
2162  pPacket->iArgs++; /* Increment arg counter of this packet */
2163 
2164  pPacket->lMsgLength += (pNewArg->lLength + BCAP_SIZE_ARGLEN);
2165  /* Add arg size into Packet length */
2166  hr = BCAP_S_OK;
2167  }
2168  else{
2169 
2170  /* Bad pointer */
2171  hr = BCAP_E_FAIL;
2172  }
2173 
2174  return hr;
2175 }
2176 
2185 static void Packet_Release( BCAP_PACKET *pPacket){
2186 
2187 
2188  /* release poacket */
2189  if (pPacket != NULL){
2190  /* release all args */
2191  Arg_Release(pPacket->pArg);
2192 
2193  /* release instance of the packet */
2194  bFree(pPacket);
2195  }
2196 }
2197 
2206 static BCAP_PACKET *Packet_Create( u_int lFuncID){
2207 
2208  BCAP_PACKET *pNewPacket = NULL;
2209 
2210  pNewPacket = (BCAP_PACKET *)bMalloc(sizeof(BCAP_PACKET)); /* alloc packet */
2211  if (pNewPacket != NULL){
2212 
2213  pNewPacket->iArgs = 0; /* args count */
2214  pNewPacket->iReserved = 0;
2215  pNewPacket->iSerialNo = m_iSerialNo;
2216  pNewPacket->lFuncID = lFuncID;
2217 
2218  pNewPacket->lMsgLength = BCAP_SIZE_BASE;
2219 #if BCAP_CONNECTION_COM /* COM */
2220  pNewPacket->lMsgLength += BCAP_SIZE_CRC;
2221 #endif
2222  pNewPacket->pArg = NULL;
2223 
2224  m_iSerialNo++; /* increment serial number */
2225  if (m_iSerialNo == 0){
2226  m_iSerialNo = 1; /* Not use Zero as a serial number */
2227  }
2228  }
2229 
2230  return pNewPacket;
2231 }
2232 
2233 
2234 
2244 static BCAP_HRESULT Packet_Serialize(BCAP_PACKET *pSrcPacket, void *pDstBinData){
2245 
2246 
2247  BCAP_HRESULT hr = BCAP_S_OK;
2248  u_char *pDstPtr;
2249 
2250  pDstPtr = (u_char *)pDstBinData;
2251 
2252  /* SOH */
2253  *pDstPtr = BCAP_SOH;
2254  pDstPtr += BCAP_SIZE_SOH;
2255  /* Header */
2256  pDstPtr += copyValue( pDstPtr, &(pSrcPacket->lMsgLength), sizeof(pSrcPacket->lMsgLength));
2257  pDstPtr += copyValue( pDstPtr, &(pSrcPacket->iSerialNo), sizeof(pSrcPacket->iSerialNo));
2258  pDstPtr += copyValue( pDstPtr, &(pSrcPacket->iReserved), sizeof(pSrcPacket->iReserved));
2259  pDstPtr += copyValue( pDstPtr, &(pSrcPacket->lFuncID), sizeof(pSrcPacket->lFuncID));
2260  pDstPtr += copyValue( pDstPtr, &(pSrcPacket->iArgs), sizeof(pSrcPacket->iArgs));
2261 
2262 
2263  { /* Copy args */
2264  unsigned int i,j;
2265  BCAP_ARG *pArgPtr;
2266  u_char *pbValue;
2267  pArgPtr = pSrcPacket->pArg;
2268 
2269  for (i =0 ; i < pSrcPacket->iArgs ; i++){
2270  if (pArgPtr != NULL){
2271  {
2272  pDstPtr += copyValue( pDstPtr, &(pArgPtr->lLength), sizeof(pArgPtr->lLength));
2273  pDstPtr += copyValue( pDstPtr, &(pArgPtr->iType), sizeof(pArgPtr->iType));
2274  pDstPtr += copyValue( pDstPtr, &(pArgPtr->lArrays), sizeof(pArgPtr->lArrays));
2275 
2276  pbValue = (u_char *)pArgPtr->data; /* value stored pointer is set */
2277 
2278  for (j= 0; j < pArgPtr->lArrays; j++){
2279  u_int lValueSize;
2280  u_short iVarType = pArgPtr->iType & ~VT_ARRAY; /* Mask "Array" */
2281  switch (iVarType){
2282  case VT_UI1:
2283  case VT_I2:
2284  case VT_UI2:
2285  case VT_I4:
2286  case VT_UI4:
2287  case VT_R4:
2288  case VT_R8:
2289  case VT_BOOL:
2290  {
2291  lValueSize = sizeOfVarType(iVarType);
2292  pDstPtr += copyValue( pDstPtr, pbValue, lValueSize);
2293  pbValue += lValueSize; /* value stored pointer is added */
2294  }
2295  break;
2296 
2297  case VT_BSTR:
2298  {
2299  u_int lStrLen;
2300  copyValue( &lStrLen, pbValue, BCAP_SIZE_ARGSTRLEN);
2301  pDstPtr += copyValue( pDstPtr, &lStrLen, BCAP_SIZE_ARGSTRLEN); /* Set String length (4 bytes) */
2302  pbValue += BCAP_SIZE_ARGSTRLEN; /* value stored pointer is added */
2303 
2304  pDstPtr += copyValue( pDstPtr, pbValue, lStrLen); /* Set string data */
2305  pbValue += lStrLen;
2306  }
2307  break;
2308 
2309  case VT_VARIANT:
2310  /* NOT_IMPLEMENT */
2311  {
2312 
2313 
2314  }
2315 
2316 
2317  break;
2318 
2319  default:
2320  break;
2321  }
2322  }
2323 
2324  }
2325  pArgPtr = pArgPtr->pNextArg; /* Set pointer to the next arg. */
2326  }
2327  }
2328 
2329  }
2330 
2331 #if BCAP_CONNECTION_COM /* COM */
2332  { /* CRC calculation */
2333  u_int dwPos, cnt;
2334  u_short crc;
2335  crc = 0xFFFF;
2336  for (dwPos = 1; dwPos < pSrcPacket->lMsgLength - 3; dwPos++) {
2337  crc ^= (((u_char *)pDstBinData)[dwPos] << 8);
2338  for (cnt = 0; cnt < 8; cnt++) {
2339  if (crc & 0x8000) {
2340  crc = (crc << 1) ^ 0x1021; /* CRC-CCITT */
2341  }
2342  else {
2343  crc <<= 1;
2344  }
2345  }
2346  }
2347  pDstPtr += copyValue( pDstPtr, &crc, sizeof(crc));
2348  }
2349 #endif
2350 
2351  /* EOT */
2352  *pDstPtr = BCAP_EOT;
2353  pDstPtr += BCAP_SIZE_EOT;
2354 
2355  return hr;
2356 }
2357 
2358 
2370 static BCAP_HRESULT Packet_Deserialize(void *pSrcBinData, BCAP_PACKET *pDstPacket){
2371 
2372 
2373  BCAP_HRESULT hr = BCAP_S_OK;
2374  u_char *pSrcPtr;
2375 
2376  u_short iArgs;
2377  u_int lMsgLength;
2378 
2379  pSrcPtr = (u_char *)pSrcBinData;
2380 
2381  /* SOH */
2382  /* pDstPtr += copyValue( &(pDstPacket->Header), pDstPtr, BCAP_SIZE_SOH)); */
2383  pSrcPtr += BCAP_SIZE_SOH;
2384 
2385  /* Header */
2386  /* "pkt->lMsgLength" and "pkt->lArgs" are calcurated in Packet_AddArg() automatically */
2387  pSrcPtr += copyValue( &lMsgLength , pSrcPtr, sizeof(pDstPacket->lMsgLength)); /* calcurated in Packet_AddArg() automatically */
2388  pSrcPtr += copyValue( &(pDstPacket->iSerialNo) , pSrcPtr, sizeof(pDstPacket->iSerialNo));
2389  pSrcPtr += copyValue( &(pDstPacket->iReserved) , pSrcPtr, sizeof(pDstPacket->iReserved));
2390  pSrcPtr += copyValue( &(pDstPacket->lFuncID) , pSrcPtr, sizeof(pDstPacket->lFuncID));
2391  pSrcPtr += copyValue( &iArgs , pSrcPtr, sizeof(pDstPacket->iArgs)); /* calcurated in Packet_AddArg() automatically */
2392 
2393 
2394  { /* Copy args */
2395  unsigned int i;
2396  BCAP_ARG *pArgPtr;
2397  pArgPtr = pDstPacket->pArg;
2398 
2399  for (i = 0 ; i < iArgs ; i++){
2400  u_int lDataSize; /* size of "*data" */
2401  u_int lLength; /* size of argument block */
2402  u_short iType;
2403  u_int lArrays;
2404 
2405  pSrcPtr += copyValue( &lLength, pSrcPtr, sizeof(lLength)); /* size of a argument block */
2406  pSrcPtr += copyValue( &iType, pSrcPtr, sizeof(iType));
2407  pSrcPtr += copyValue( &lArrays, pSrcPtr, sizeof(lArrays));
2408 
2409  lDataSize = lLength - BCAP_SIZE_ARGTYPE -BCAP_SIZE_ARGARRAYS; /* size of "*data" */
2410 
2411  pArgPtr = Arg_Create(iType, lArrays, lDataSize, pSrcPtr); /* Create new arg */
2412  if (pArgPtr != NULL){
2413  pSrcPtr = pSrcPtr + lDataSize; /* skip "*data" */
2414  }
2415  else{
2416  hr = BCAP_E_FAIL;
2417  break;
2418  }
2419 
2420  if (Packet_AddArg(pDstPacket, pArgPtr) != BCAP_S_OK){ /* Add new arg to packet */
2421  Arg_Release(pArgPtr); /* Fail to add, then release this arg. */
2422  hr = BCAP_E_FAIL;
2423  break;
2424  }
2425  }
2426 
2427  }
2428 
2429 #if BCAP_CONNECTION_COM /* COM */
2430  {
2431  u_short iCRC;
2432  /* CRC */
2433  pSrcPtr += copyValue(&iCRC, pSrcPtr, sizeof(iCRC));
2434  }
2435 #endif
2436 
2437  /* EOT */
2438  if (hr == BCAP_S_OK){
2439  if (*pSrcPtr != BCAP_EOT){ /* If end of the binnary is not EOT, then error */
2440  hr = BCAP_E_UNEXPECTED;
2441  }
2442  }
2443  pSrcPtr += BCAP_SIZE_EOT;
2444 
2445  return hr;
2446 }
2447 
2456 BCAP_HRESULT Packet_GetResult(BCAP_PACKET *pRecPacket, void *pResult){
2457 
2458  BCAP_HRESULT hr = BCAP_E_FAIL;
2459 
2460  if (pRecPacket != NULL){
2461  if (pRecPacket->iArgs >= 1){
2462  { /* Copy values */
2463  u_int i;
2464  u_int lSize;
2465  u_short iType;
2466  BCAP_ARG *pArgValue = pRecPacket->pArg;
2467 
2468  iType = (pArgValue->iType) & ~VT_ARRAY; /* Mask "Array" */
2469  if (iType == VT_BSTR){
2470  u_char *pDstAscii = (u_char *)pResult;
2471  u_char *pSrcBstr = (u_char *)pArgValue->data;
2472 
2473  for (i = 0;i < pArgValue->lArrays;i++){
2474  lSize = copyFromBSTR(pDstAscii, pSrcBstr);
2475  pDstAscii += lSize;
2476  pSrcBstr += BCAP_SIZE_ARGSTRLEN + ((lSize -1) * 2); /* lSize include Terminator,so (lSize -1) * 2) */
2477  }
2478  }
2479  else{
2480  lSize = sizeOfVarType((u_short)(pArgValue->iType));
2481  if (lSize != 0){
2482  u_char *pDst = (u_char *)pResult;
2483  u_char *pSrc = (u_char *)(u_char *)pArgValue->data;
2484 
2485  for (i = 0;i < pArgValue->lArrays;i++){
2486  copyValue(pDst, pSrc, lSize);
2487  pDst += lSize;
2488  pSrc += lSize;
2489  }
2490  }
2491  }
2492  }
2493  }
2494  else{
2495  /* NO Argument */
2496  }
2497  hr = BCAP_S_OK;
2498  }
2499  return hr;
2500 }
2501 
2515 static BCAP_ARG *Arg_Create( u_short iType, u_int lArrays, u_int lDataSize, void *data){
2516 
2517  BCAP_ARG *pNewArg = NULL;
2518 
2519  if ((lDataSize < BCAP_MAX_ARG_SIZE)){ /* (0 < ) has something data, (<BCAP_MAX_ARG_SIZE) not over size */
2520 
2521  pNewArg = (BCAP_ARG *)bMalloc(sizeof(BCAP_ARG)); /* alloc argument */
2522  if (pNewArg != NULL){
2523  pNewArg->iType = iType;
2524  pNewArg->lArrays = lArrays;
2525  pNewArg->lLength = lDataSize + BCAP_SIZE_ARGTYPE + BCAP_SIZE_ARGARRAYS;
2526  pNewArg->pNextArg = NULL;
2527  pNewArg->data = NULL;
2528 
2529  pNewArg->data = bMalloc(lDataSize);
2530  if (pNewArg->data != NULL ){
2531  if (data != NULL){
2532  memcpy(pNewArg->data, data, lDataSize);
2533  }
2534  else{
2535  /* Fail to copy from *data, then release this argumant. */
2536  Arg_Release(pNewArg);
2537  pNewArg = NULL; /* return value (allocated pointer) */
2538  }
2539 
2540  }
2541  else{ /* fail to alloc memory */
2542  /* Fail to alloc memory, then release this argumant. */
2543  Arg_Release(pNewArg);
2544  pNewArg = NULL; /* return value (allocated pointer) */
2545  }
2546  }
2547  }
2548 
2549 
2550  return pNewArg;
2551 }
2552 
2553 
2562 static void Arg_Release( BCAP_ARG *pArg){
2563 
2564  while (pArg != NULL){
2565  BCAP_ARG *pNextArg;
2566 
2567  pNextArg = pArg->pNextArg; /* store next pointer in temporary */
2568 
2569  if (pArg->data != NULL){
2570  bFree(pArg->data); /* free value of argument */
2571  }
2572 
2573  bFree(pArg); /* free argument */
2574  pArg = pNextArg; /* set next pointer */
2575  }
2576 }
2577 
2578 
2579 
2589 static u_int sizeOfVariant(BCAP_VARIANT vntValue){
2590  u_int lSize = 0;
2591 
2592  if (vntValue.Arrays > 0) {
2593  switch (vntValue.Type & ~VT_ARRAY){
2594  case VT_BSTR:
2595  {
2596  u_int i;
2597  u_int lStrLen;
2598  char *pData;
2599 
2600  pData = (char *)(&vntValue.Value);
2601  for (i =0; i < vntValue.Arrays; i++){
2602  lStrLen = (u_int)strlen(pData);
2603  lSize += lStrLen;
2604  pData += lStrLen;
2605  }
2606  }
2607  break;
2608  default:
2609  lSize = sizeOfVarType(vntValue.Type) * vntValue.Arrays;
2610  break;
2611  }
2612  }
2613  else{
2614  lSize = 0;
2615  }
2616 
2617  return lSize;
2618 }
2619 
2629 static u_int sizeOfVarType(u_short iType){
2630 
2631  u_int lValueSize = 0;
2632 
2633  switch (iType & ~VT_ARRAY){
2634  case VT_UI1:
2635  lValueSize = 1;
2636  break;
2637  case VT_I2:
2638  lValueSize = 2;
2639  break;
2640  case VT_UI2:
2641  lValueSize = 2;
2642  break;
2643  case VT_I4:
2644  lValueSize = 4;
2645  break;
2646  case VT_UI4:
2647  lValueSize = 4;
2648  break;
2649  case VT_R4:
2650  lValueSize = 4;
2651  break;
2652  case VT_R8:
2653  lValueSize = 8;
2654  break;
2655  case VT_BOOL:
2656  lValueSize = 2;
2657  break;
2658  case VT_BSTR:
2659  /* In this function */
2660  lValueSize = BCAP_SIZE_ARGSTRLEN;
2661  break;
2662 
2663  case VT_VARIANT: /* Not implement */
2664  break;
2665 
2666  default: /* Not implement */
2667  /* VT_EMPTY */
2668  /* VT_NULL */
2669  /* VT_ERROR */
2670  /* VT_CY */
2671  /* VT_DATE */
2672  break;
2673  }
2674 
2675  return lValueSize;
2676 }
2677 
2687  u_int copyToBSTR(void *pDstBstrPtr, void *pSrcAsciiPtr){
2688  u_char *pbDst = (u_char *)pDstBstrPtr;
2689  u_char *pbSrc = (u_char *)pSrcAsciiPtr;
2690  u_int lStrLen,lLen2;
2691  u_int i;
2692 
2693  lStrLen = strlen((const char *)pbSrc); /* length of source string (ascii) */
2694  lLen2 = lStrLen * 2;
2695 
2696  if (pbDst != NULL){
2697  pbDst += copyValue(pbDst, &lLen2, BCAP_SIZE_ARGSTRLEN);
2698 
2699  for (i = 0;i < lStrLen; i++){
2700  *pbDst++ = *pbSrc++;
2701  *pbDst++ = 0;
2702  }
2703 
2704  }
2705  return (lStrLen * 2 + BCAP_SIZE_ARGSTRLEN);
2706 }
2707 
2717 static u_int copyFromBSTR(void *pDstAsciiPtr, void *pSrcBstrPtr){
2718  u_char *pbDst = (u_char *)pDstAsciiPtr;
2719  u_char *pbSrc = (u_char *)pSrcBstrPtr;
2720  u_int lStrLen,lLen2;
2721  u_int i;
2722 
2723  copyValue(&lStrLen, pbSrc, BCAP_SIZE_ARGSTRLEN); /* Get BStr length */
2724  pbSrc += BCAP_SIZE_ARGSTRLEN;
2725 
2726  lLen2 = lStrLen / 2;
2727 
2728  if (pbDst != NULL){
2729  for (i = 0;i < lLen2; i++){
2730  *pbDst = *pbSrc;
2731  pbDst += 1; /* Ascii */
2732  pbSrc += 2; /* BSTR */
2733 
2734  }
2735  *pbDst = 0; /* Zero termination */
2736  lLen2++; /* +1 = (Zero termination) */
2737  }
2738  return (lLen2);
2739 }
2740 
2741 
2751 static u_int copyVariantFromArg(BCAP_VARIANT *pVntDst, BCAP_ARG *pArg){
2752 
2753  u_int i;
2754  u_int lSize;
2755  u_short iType;
2756  u_int lLength = 0;
2757 
2758  if ((pVntDst != NULL) && (pArg != NULL)){
2759 
2760  pVntDst->Type = pArg->iType;
2761  pVntDst->Arrays = pArg->lArrays;
2762  // pVntDst->Value
2763 
2764 
2765  iType = (pArg->iType) & ~VT_ARRAY; /* Mask "Array" */
2766  if (iType == VT_BSTR){
2767  u_char *pDstAscii = (u_char *)(&(pVntDst->Value));
2768  u_char *pSrcBstr = (u_char *)pArg->data;
2769 
2770  for (i = 0;i < pArg->lArrays;i++){
2771  lSize = copyFromBSTR(pDstAscii, pSrcBstr);
2772  pDstAscii += lSize;
2773  pSrcBstr += BCAP_SIZE_ARGSTRLEN + ((lSize -1) * 2); /* lSize include Terminator,so (lSize -1) * 2) */
2774  }
2775  }
2776  else{
2777  lSize = sizeOfVarType((u_short)(pArg->iType));
2778  if (lSize != 0){
2779  u_char *pDstPtr = (u_char *)(&(pVntDst->Value));
2780  u_char *pSrcPtr = (u_char *)pArg->data;
2781 
2782  for (i = 0;i < pArg->lArrays;i++){
2783  copyValue(pDstPtr, pSrcPtr, lSize);
2784  pDstPtr += lSize;
2785  pSrcPtr += lSize;
2786  }
2787  }
2788  }
2789  }
2790 
2791  return lLength; /* return copied bytes size */
2792 }
2793 
2803 /* static u_int copyArgValue(void *pDst, BCAP_ARG *pArg){ */
2804 
2805 /* u_int i; */
2806 /* u_int lSize; */
2807 /* u_short iType; */
2808 /* u_int lLength = 0; */
2809 
2810 /* iType = (pArg->iType) & ~VT_ARRAY; /\* Mask "Array" *\/ */
2811 /* if (iType == VT_BSTR){ */
2812 /* u_char *pDstAscii = (u_char *)pDst; */
2813 /* u_char *pSrcBstr = (u_char *)pArg->data; */
2814 
2815 /* for (i = 0;i < pArg->lArrays;i++){ */
2816 /* lSize = copyFromBSTR(pDstAscii, pSrcBstr); */
2817 /* pDstAscii += lSize; */
2818 /* pSrcBstr += BCAP_SIZE_ARGSTRLEN + ((lSize -1) * 2); /\* lSize include Terminator,so (lSize -1) * 2) *\/ */
2819 /* } */
2820 /* } */
2821 /* else{ */
2822 /* lSize = sizeOfVarType((u_short)(pArg->iType)); */
2823 /* if (lSize != 0){ */
2824 /* //u_char *pDstPtr = (u_char *)pDst; */
2825 /* u_char *pSrcPtr = (u_char *)pArg->data; */
2826 
2827 /* for (i = 0;i < pArg->lArrays;i++){ */
2828 /* copyValue(pSrcPtr, pSrcPtr, lSize); */
2829 /* pSrcPtr += lSize; */
2830 /* pSrcPtr += lSize; */
2831 /* } */
2832 /* } */
2833 /* } */
2834 
2835 
2836 /* return lLength; /\* return copied bytes size *\/ */
2837 /* } */
2838 
2839 
2840  /*
2841  * copy value in the "Little Endian"
2842  *
2843  * alternate of htonl()/ntohl()
2844  */
2845 static u_int copyValue(void *pDst, void *pVntValue, u_int lLength){
2846 
2847 #if defined(__BIG_ENDIAN__)
2848 
2849  /* SPARC/MC68xxx */
2850 
2851  /* copy values inversion. b-CAP is based on little-endian */
2852  {
2853  u_int i;
2854 
2855  u_char *pbDst;
2856  u_char *pbSrc;
2857 
2858  pbSrc = (u_char *)(pVntValue) + lLength -1;
2859  pbDst = (u_char *)pDst;
2860 
2861  for (i = 0 ; i < lLength ; i++){
2862  *pbDst++ = *pbSrc--;
2863  }
2864  }
2865 #else
2866 
2867  memcpy(pDst, pVntValue, lLength);
2868 #endif
2869 
2870  return lLength; /* return copied bytes size */
2871 }
2872 
2873 /*
2874  * Memory allocation counter
2875  */
2876 static long m_lAllocCount = 0;
2877 static long m_lAllocSize = 0;
2878 
2879 /*
2880  * alternative of Malloc()
2881  */
2882 static void *bMalloc(size_t size){
2883 
2884  void *pPtr;
2885 
2886  m_lAllocCount++;
2887  m_lAllocSize += size;
2888 
2889  pPtr = malloc(size);
2890 
2891 #ifdef DEBUG
2892  printf("AllocCount:%d\n",m_lAllocCount);
2893 #endif
2894 
2895  return pPtr;
2896 }
2897 
2898 /*
2899  * alternative of Free()
2900  */
2901 static void bFree(void *pPtr){
2902 
2903  m_lAllocCount--;
2904 #ifdef DEBUG
2905  printf("AllocCount:%d\n",m_lAllocCount);
2906 #endif
2907  free(pPtr);
2908 }
2909 
2910 
2911 
BCAP_FUNC_Robot_Move
#define BCAP_FUNC_Robot_Move
Definition: b-Cap.c:123
BCAP_FUNC_Controller_Execute
#define BCAP_FUNC_Controller_Execute
Definition: b-Cap.c:118
bCap_VariableRelease
BCAP_HRESULT bCap_VariableRelease(int iSockFd, u_int lhVar)
Definition: b-Cap.c:1633
BCAP_SIZE_ARGARRAYS
#define BCAP_SIZE_ARGARRAYS
Definition: b-Cap.c:100
b-Cap.h
b-CAP client library header
BCAP_SIZE_BASE
#define BCAP_SIZE_BASE
Definition: b-Cap.c:91
Packet_Send
static BCAP_HRESULT Packet_Send(int iSd, BCAP_PACKET *pPacket)
Definition: b-Cap.c:2079
bCap_ControllerExecute
BCAP_HRESULT bCap_ControllerExecute(int iSockFd, u_int lhController, char *pStrCommand, char *pStrOption, void *pResult)
Definition: b-Cap.c:800
BCAP_FUNC_Service_Start
#define BCAP_FUNC_Service_Start
Definition: b-Cap.c:111
BCAP_PACKET::lFuncID
u_int lFuncID
Definition: b-Cap.c:163
BCAP_FUNC_Task_Release
#define BCAP_FUNC_Task_Release
Definition: b-Cap.c:129
BCAP_PACKET
struct BCAP_PACKET BCAP_PACKET
BCAP_ARG::lLength
u_int lLength
Definition: b-Cap.c:142
BCAP_SIZE_EOT
#define BCAP_SIZE_EOT
Definition: b-Cap.c:82
BCAP_SIZE_CRC
#define BCAP_SIZE_CRC
Definition: b-Cap.c:88
bCap_Close
BCAP_HRESULT bCap_Close(int iSockFd)
Definition: b-Cap.c:359
VT_I4
#define VT_I4
Definition: b-Cap.h:74
BCAP_FUNC_Controller_GetRobot
#define BCAP_FUNC_Controller_GetRobot
Definition: b-Cap.c:115
BCAP_HRESULT
BCAP_HRESULT
BCAP_HRESULT values.
Definition: b-Cap.h:38
BCAP_SIZE_LEN
#define BCAP_SIZE_LEN
Definition: b-Cap.c:83
bCap_RobotMove
BCAP_HRESULT bCap_RobotMove(int iSockFd, u_int lhRobot, long lComp, char *pStrPose, char *pStrOption)
Definition: b-Cap.c:1252
BCAP_FUNC_Variable_GetValue
#define BCAP_FUNC_Variable_GetValue
Definition: b-Cap.c:132
BCAP_VARIANT::Type
u_short Type
Definition: b-Cap.h:110
u_int
unsigned int u_int
Definition: b-Cap.h:104
VT_BSTR
#define VT_BSTR
Definition: b-Cap.h:81
m_iSerialNo
static u_short m_iSerialNo
Definition: b-Cap.c:206
BCAP_FUNC_Robot_Change
#define BCAP_FUNC_Robot_Change
Definition: b-Cap.c:122
Packet_Release
static void Packet_Release(BCAP_PACKET *pPacket)
Definition: b-Cap.c:2185
copyFromBSTR
static u_int copyFromBSTR(void *pDstAsciiPtr, void *pSrcBstrPtr)
Definition: b-Cap.c:2717
BCAP_SIZE_RESERVE
#define BCAP_SIZE_RESERVE
Definition: b-Cap.c:85
BCAP_SOH
#define BCAP_SOH
Definition: b-Cap.c:79
bCap_TaskStart
BCAP_HRESULT bCap_TaskStart(int iSockFd, u_int lhTask, long lMode, char *pStrOption)
Definition: b-Cap.c:1503
VT_R4
#define VT_R4
Definition: b-Cap.h:76
VT_BOOL
#define VT_BOOL
Definition: b-Cap.h:80
bCap_VariablePutValue
BCAP_HRESULT bCap_VariablePutValue(int iSockFd, u_int lhVar, u_short iType, u_int lArrays, void *pVntValue)
Definition: b-Cap.c:1727
failed_to_send_packet
int failed_to_send_packet
Definition: b-Cap.c:1824
VT_VARIANT
#define VT_VARIANT
Definition: b-Cap.h:83
BCAP_FUNC_Controller_GetTask
#define BCAP_FUNC_Controller_GetTask
Definition: b-Cap.c:116
LOCALBUFFER_SZ
#define LOCALBUFFER_SZ
Definition: b-Cap.c:73
BCAP_ARG::pNextArg
struct BCAP_ARG * pNextArg
Definition: b-Cap.c:148
Packet_Serialize
static BCAP_HRESULT Packet_Serialize(BCAP_PACKET *pPacket, void *pBinData)
Definition: b-Cap.c:2244
sizeOfVarType
static u_int sizeOfVarType(u_short iType)
Definition: b-Cap.c:2629
BCAP_PACKET::iSerialNo
u_short iSerialNo
Definition: b-Cap.c:160
BCAP_ARG
BCAP_ARG.
Definition: b-Cap.c:141
bCap_ControllerDisconnect
BCAP_HRESULT bCap_ControllerDisconnect(int iSockFd, u_int lhController)
Definition: b-Cap.c:542
BCAP_ARG::data
void * data
Definition: b-Cap.c:146
BCAP_VARIANT::Value
union BCAP_VARIANT::@0 Value
VT_UI2
#define VT_UI2
Definition: b-Cap.h:73
Arg_Create
static BCAP_ARG * Arg_Create(u_short iType, u_int lArrays, u_int lLength, void *data)
Definition: b-Cap.c:2515
shutdown
void shutdown(boost::shared_ptr< DensoRobotHW > robot, boost::shared_ptr< ros::AsyncSpinner > spinner)
Definition: main.cpp:11
bMalloc
static void * bMalloc(size_t size)
Definition: b-Cap.c:2882
Packet_Create
static BCAP_PACKET * Packet_Create(u_int lFuncID)
Definition: b-Cap.c:2206
copyVariantFromArg
static u_int copyVariantFromArg(BCAP_VARIANT *pVntDst, BCAP_ARG *pArg)
Definition: b-Cap.c:2751
BCAP_ARG::lArrays
u_int lArrays
Definition: b-Cap.c:145
u_short
unsigned short u_short
Definition: b-Cap.h:101
sizeOfVariant
static u_int sizeOfVariant(BCAP_VARIANT vntValue)
Definition: b-Cap.c:2589
bCap_ControllerConnect
BCAP_HRESULT bCap_ControllerConnect(int iSockFd, char *pStrCtrlname, char *pStrProvName, char *pStrPcName, char *pStrOption, u_int *plhController)
Definition: b-Cap.c:467
VT_UI4
#define VT_UI4
Definition: b-Cap.h:75
BCAP_FUNC_Robot_GetVariable
#define BCAP_FUNC_Robot_GetVariable
Definition: b-Cap.c:120
BCAP_SIZE_FUNCID
#define BCAP_SIZE_FUNCID
Definition: b-Cap.c:86
Packet_AddArg
static BCAP_HRESULT Packet_AddArg(BCAP_PACKET *pPacket, BCAP_ARG *pNewArg)
Definition: b-Cap.c:2145
BCAP_FUNC_Robot_Execute
#define BCAP_FUNC_Robot_Execute
Definition: b-Cap.c:121
BCAP_FUNC_Controller_Disconnect
#define BCAP_FUNC_Controller_Disconnect
Definition: b-Cap.c:114
BCAP_PACKET::iReserved
u_short iReserved
Definition: b-Cap.c:161
BCAP_PACKET::lMsgLength
u_int lMsgLength
Definition: b-Cap.c:158
bCap_RobotRelease
BCAP_HRESULT bCap_RobotRelease(int iSockFd, u_int lhRobot)
Definition: b-Cap.c:936
BCAP_FUNC_Robot_Release
#define BCAP_FUNC_Robot_Release
Definition: b-Cap.c:124
copyValue
static u_int copyValue(void *pDst, void *pVntValue, u_int lLength)
Definition: b-Cap.c:2845
VT_I2
#define VT_I2
Definition: b-Cap.h:72
BCAP_EOT
#define BCAP_EOT
Definition: b-Cap.c:80
BCAP_FUNC_Service_Stop
#define BCAP_FUNC_Service_Stop
Definition: b-Cap.c:112
BCAP_FUNC_Task_GetVariable
#define BCAP_FUNC_Task_GetVariable
Definition: b-Cap.c:126
SERIAL_BAUDRATE
#define SERIAL_BAUDRATE
Definition: b-Cap.h:32
VT_UI1
#define VT_UI1
Definition: b-Cap.h:71
bCap_ServiceStop
BCAP_HRESULT bCap_ServiceStop(int iSockFd)
Definition: b-Cap.c:428
bCap_ControllerGetTask
BCAP_HRESULT bCap_ControllerGetTask(int iSockFd, u_int lhController, char *pTskName, char *pstrOption, u_int *plhVar)
Definition: b-Cap.c:726
bCap_ServiceStart
BCAP_HRESULT bCap_ServiceStart(int iSockFd)
Definition: b-Cap.c:396
BCAP_SIZE_ARGNUM
#define BCAP_SIZE_ARGNUM
Definition: b-Cap.c:87
SUCCEEDED
#define SUCCEEDED(Status)
Definition: b-Cap.h:89
bCap_TaskRelease
BCAP_HRESULT bCap_TaskRelease(int iSockFd, u_int lhTask)
Definition: b-Cap.c:1389
VT_R8
#define VT_R8
Definition: b-Cap.h:77
bCap_TaskStop
BCAP_HRESULT bCap_TaskStop(int iSockFd, u_int lhTask, long lMode, char *pStrOption)
Definition: b-Cap.c:1569
BCAP_SIZE_ARGLEN
#define BCAP_SIZE_ARGLEN
Definition: b-Cap.c:98
bCap_ControllerExecute2
BCAP_HRESULT bCap_ControllerExecute2(int iSockFd, u_int lhController, char *pStrCommand, BCAP_VARIANT *pVntOption, BCAP_VARIANT *pVntResult)
Definition: b-Cap.c:867
BCAP_FUNC_Controller_GetVariable
#define BCAP_FUNC_Controller_GetVariable
Definition: b-Cap.c:117
BCAP_FUNC_Task_Start
#define BCAP_FUNC_Task_Start
Definition: b-Cap.c:127
VT_ARRAY
#define VT_ARRAY
Definition: b-Cap.h:84
bCap_RobotExecute
BCAP_HRESULT bCap_RobotExecute(int iSockFd, u_int lhRobot, char *pStrCommand, char *pStrOption, void *pResult)
Definition: b-Cap.c:1054
BCAP_MAX_ARG_SIZE
#define BCAP_MAX_ARG_SIZE
Definition: b-Cap.c:107
bCap_RobotExecuteSlaveMove
BCAP_HRESULT bCap_RobotExecuteSlaveMove(int iSockFd, u_int lhRobot, char *pStrCommand, float *pfOption, void *pResult)
Definition: b-Cap.c:1327
m_lAllocCount
static long m_lAllocCount
Definition: b-Cap.c:2876
bFree
static void bFree(void *pPtr)
Definition: b-Cap.c:2901
BCAP_FUNC_Controller_Connect
#define BCAP_FUNC_Controller_Connect
Definition: b-Cap.c:113
copyToBSTR
static u_int copyToBSTR(void *pbDstPtr, void *pbSrcPtr)
Definition: b-Cap.c:2687
BCAP_SIZE_ARGTYPE
#define BCAP_SIZE_ARGTYPE
Definition: b-Cap.c:99
Packet_GetLastArgHandle
static BCAP_ARG ** Packet_GetLastArgHandle(BCAP_PACKET *pPacket)
Definition: b-Cap.c:2109
bCap_VariableGetValue
BCAP_HRESULT bCap_VariableGetValue(int iSockFd, u_int lhVar, void *pVntValue)
Definition: b-Cap.c:1676
bCap_Open
BCAP_HRESULT bCap_Open(const char *pIPStr, int iPort, int *iSockFd)
Definition: b-Cap.c:225
bCap_ControllerGetRobot
BCAP_HRESULT bCap_ControllerGetRobot(int iSockFd, u_int lhController, char *pStrRobotName, char *pStrOption, u_int *plhRobot)
Definition: b-Cap.c:587
bCap_RobotExecute2
BCAP_HRESULT bCap_RobotExecute2(int iSockFd, u_int lhRobot, char *pStrCommand, BCAP_VARIANT *pVntOption, BCAP_VARIANT *pVntResult)
Definition: b-Cap.c:1121
BCAP_PACKET
BCAP_PACKET.
Definition: b-Cap.c:156
BCAP_ARG::iType
u_short iType
Definition: b-Cap.c:144
bCap_RobotChange
BCAP_HRESULT bCap_RobotChange(int iSockFd, u_int lhRobot, char *pStrCommand)
Definition: b-Cap.c:1194
Packet_GetResult
static BCAP_HRESULT Packet_GetResult(BCAP_PACKET *pRecPacket, void *pResult)
Definition: b-Cap.c:2456
BCAP_VARIANT::Arrays
u_int Arrays
Definition: b-Cap.h:111
BCAP_SIZE_ARGSTRLEN
#define BCAP_SIZE_ARGSTRLEN
Definition: b-Cap.c:103
u_char
unsigned char u_char
Definition: b-Cap.h:98
bCap_TaskGetVariable
BCAP_HRESULT bCap_TaskGetVariable(int iSockFd, u_int lhTask, char *pVarName, char *pstrOption, u_int *plhVar)
Definition: b-Cap.c:1434
bCap_RobotGetVariable
BCAP_HRESULT bCap_RobotGetVariable(int iSockFd, u_int lhRobot, char *pVarName, char *pstrOption, u_int *plhVar)
Definition: b-Cap.c:982
BCAP_SIZE_SERIAL
#define BCAP_SIZE_SERIAL
Definition: b-Cap.c:84
Packet_Deserialize
static BCAP_HRESULT Packet_Deserialize(void *pBinData, BCAP_PACKET *pPacket)
Definition: b-Cap.c:2370
bCapSendAndRec
static BCAP_HRESULT bCapSendAndRec(int iSockFd, BCAP_PACKET *pSndPacket, BCAP_PACKET *pRecPacket)
Definition: b-Cap.c:1825
bCap_ControllerGetVariable
BCAP_HRESULT bCap_ControllerGetVariable(int iSockFd, u_int lhController, char *pVarName, char *pstrOption, u_int *plhVar)
Definition: b-Cap.c:655
BCAP_VARIANT
Definition: b-Cap.h:109
BCAP_FUNC_Variable_PutValue
#define BCAP_FUNC_Variable_PutValue
Definition: b-Cap.c:133
BCAP_PACKET::pArg
struct BCAP_ARG * pArg
Definition: b-Cap.c:167
BCAP_FUNC_Task_Stop
#define BCAP_FUNC_Task_Stop
Definition: b-Cap.c:128
LOCALRECBUFFER_SZ
#define LOCALRECBUFFER_SZ
Definition: b-Cap.c:75
m_lAllocSize
static long m_lAllocSize
Definition: b-Cap.c:2877
BCAP_SIZE_SOH
#define BCAP_SIZE_SOH
Definition: b-Cap.c:81
BCAP_ARG
struct BCAP_ARG BCAP_ARG
sendBinary
static BCAP_HRESULT sendBinary(int iSockFd, u_char *pBuff, u_int lSize)
Definition: b-Cap.c:2036
receivePacket
static u_char * receivePacket(int iSockFd, int *retryp)
Definition: b-Cap.c:1893
Arg_Release
static void Arg_Release(BCAP_ARG *pArg)
Definition: b-Cap.c:2562
BCAP_FUNC_Variable_Release
#define BCAP_FUNC_Variable_Release
Definition: b-Cap.c:134
BCAP_PACKET::iArgs
u_short iArgs
Definition: b-Cap.c:165

denso_ros_control
Author(s):
autogenerated on Mon Jun 10 2019 13:13:14