ClpeClientApi.cpp
Go to the documentation of this file.
1 /**********************************************************************
2  This is the ClpeClientApi Class Function of CanLab CLPE Client API.
3 **********************************************************************/
4 
5 #include "ClpeClientApi.h"
6 #include "ClpeSDKVersion.h"
7 #include "ClpeGlobalDef.h"
8 #include <string.h>
9 
10 #define MAX_CAMERA_CNT_PER_BOARD (4)
11 
12 /********************************************************
13  * ClpeClientApi Class Constructor
14 *********************************************************/
15 ClpeClientApi::ClpeClientApi()
16 {
17 
18 }
19 
20 /********************************************************
21  * ClpeClientApi Class Disconstructor
22 *********************************************************/
23 ClpeClientApi::~ClpeClientApi()
24 {
25  ClpeSocket::close(MCU_ID_MASTER);
26  if(m_isAttachedSlave == 1)
27  {
28  ClpeSocket::close(MCU_ID_SLAVE);
29  }
30 }
31 
32 /********************************************************
33  * Clpe_Send
34  - Send data to Xavier Server
35 *********************************************************/
36 bool ClpeClientApi::Clpe_Send(unsigned char *s, int mcu_id) // master (mcu_id = 0), slave (mcu_id = 1)
37 {
38  if(ClpeSocket::send(s, mcu_id))
39  {
40  return true;
41  }
42  else
43  {
44  return false;
45  }
46 }
47 
48 /********************************************************
49  * Clpe_Recv
50  - Receive data from Xavier Server
51 *********************************************************/
52 bool ClpeClientApi::Clpe_Recv(unsigned char *s, int mcu_id) // master (mcu_id = 0), slave (mcu_id = 1)
53 {
54  if(ClpeSocket::recv(s, mcu_id))
55  {
56  return true;
57  }
58  else
59  {
60  return false;
61  }
62 }
63 
64 /********************************************************
65  * Clpe_CheckConnect
66  - Check network connection between PC and Xavier
67 *********************************************************/
68 int ClpeClientApi::Clpe_CheckConnect(string password, int settingValue)
69 {
70  int ret = 0;
71  int cnt = 0;
72  int errEthUp = 0;
73  int errEthSet = 0;
74  int errPing = 0;
75  string ethDev;
76  string ethDevOther;
77  string pcIpAddress;
78  string xavierNxIpAddress;
79  string cmdEthDown;
80  string cmdEthDownOther;
81  string cmdEthUp;
82  string cmdEthSet;
83  string cmdPing;
84 
85  if(settingValue == 0)
86  {
87  ethDev = "eth0";
88  ethDevOther = "eth1";
89  pcIpAddress = " 192.168.7.8";
90  xavierNxIpAddress = "192.168.7.7";
91  }
92  else if(settingValue == 1)
93  {
94  ethDev = "eth1";
95  ethDevOther = "eth0";
96  pcIpAddress = " 192.168.7.8";
97  xavierNxIpAddress = "192.168.7.7";
98  }
99  else if(settingValue == 2)
100  {
101  ethDev = "eth1";
102  pcIpAddress = " 192.168.8.8";
103  xavierNxIpAddress = "192.168.8.7";
104  }
105  else
106  {
107  ethDev = "eth0";
108  pcIpAddress = " 192.168.8.8";
109  xavierNxIpAddress = "192.168.8.7";
110  }
111 
112  cmdEthDown = "echo '" + password + "' | sudo -kS nmcli dev disconnect " + ethDev + " > /dev/null 2>&1";
113  cmdEthDownOther = "echo '" + password + "' | sudo -kS nmcli dev disconnect " + ethDevOther + " > /dev/null 2>&1";
114  cmdEthUp = "echo '" + password + "' | sudo -kS ifconfig " + ethDev + " up > /dev/null 2>&1";
115  cmdEthSet = "echo '" + password + "' | sudo -kS ifconfig " + ethDev + pcIpAddress + " > /dev/null 2>&1";
116  cmdPing = "ping -c 1 " + xavierNxIpAddress + " -W 1 > /dev/null 2>&1";
117 
119  if(settingValue == 0 || settingValue == 1)
120  {
121  ret = system(cmdEthDown.c_str());
122  ret = system(cmdEthDownOther.c_str());
123  }
124  else
125  {
126  ret = system(cmdEthDown.c_str());
127  }
128  while(1)
129  {
131  ret = system(cmdEthUp.c_str());
132 
133  if(ret == 0)
134  {
135  errEthUp = 0;
136  cnt = 0;
137  break;
138  }
139  else
140  {
141  cnt++;
142  }
143 
144  if(cnt > 3)
145  {
146  errEthUp = 1;
147  cnt = 0;
148  break;
149  }
150 
151  usleep(500000);
152  }
153 
154  if(errEthUp)
155  {
156  return ERROR_CONNECT_NETWORK;
157  }
158 
159  while(1)
160  {
162  ret = system(cmdEthSet.c_str());
163 
164  if(ret == 0)
165  {
166  errEthSet = 0;
167  cnt = 0;
168  break;
169  }
170  else
171  {
172  cnt++;
173  }
174 
175  if(cnt > 3)
176  {
177  errEthSet = 1;
178  cnt = 0;
179  break;
180  }
181 
182  usleep(500000);
183  }
184 
185  if(errEthSet)
186  {
187  return ERROR_CONNECT_ADDRESS;
188  }
189  while(1)
190  {
192  ret = system(cmdPing.c_str());
193 
194  if(ret == 0)
195  {
196  errPing = 0;
197  cnt = 0;
198  break;
199  }
200  else
201  {
202  cnt++;
203  }
204 
205  if(cnt > 3)
206  {
207  errPing = 1;
208  cnt = 0;
209  break;
210  }
211 
212  sleep(1);
213  }
214 
215  if(errPing)
216  {
217  return ERROR_CONNECT_PING;
218  }
219 
220  usleep(500000);
221 
222  return SUCCESSED;
223 }
224 
225 /********************************************************
226  * Clpe_Initial
227  - Initial network connection between PC and Xavier
228 *********************************************************/
229 int ClpeClientApi::Clpe_Connection(string password)
230 {
231  int ret = 0;
232  int cnt = 0;
233  int errConnect = 0;
234  int masterCheckedPosition = 0;
235  int isAttachedSlave = 0;
236 
237  string cmdModule = "echo '" + password + "' | sudo -kS modprobe tegra_vnet > /dev/null 2>&1";
238 
239 
240  string cmdNet1 = "echo '" + password + "' | sudo -kS sysctl -w net.ipv4.ip_forward=1 > /dev/null 2>&1";
241  string cmdNet2 = "echo '" + password + "' | sudo -kS sysctl -w net.core.rmem_default=90000000 > /dev/null 2>&1";
242  string cmdNet3 = "echo '" + password + "' | sudo -kS sysctl -w net.core.rmem_max=90000000 > /dev/null 2>&1";
243  string cmdNet4 = "echo '" + password + "' | sudo -kS sysctl -w net.ipv4.udp_rmem_min=10000000 > /dev/null 2>&1";
244  string cmdNet5 = "echo '" + password + "' | sudo -kS sysctl -w net.ipv4.udp_mem='90000000 90000000 90000000' > /dev/null 2>&1";
245 
246  isAttachedSlave = 0; // only support 1 clpe.
247  m_isAttachedSlave = isAttachedSlave;
249  ret = system(cmdModule.c_str());
250 
251  if(ret != 0)
252  {
253  return ERROR_CONNECT_DRIVER;
254  }
255 
256  usleep(500000);
257 
258  /* Check the connection for master */
259  masterCheckedPosition = 0;
260  ret = Clpe_CheckConnect(password, 0);
261  if(ret != SUCCESSED)
262  {
263  masterCheckedPosition = 1;
264  ret = Clpe_CheckConnect(password, 1);
265  if(ret != SUCCESSED)
266  {
267  return ret;
268  }
269  }
270 
271  if(isAttachedSlave == 1)
272  {
273  /* Check the connection for slave */
274  if(masterCheckedPosition == 0)
275  {
276  ret = Clpe_CheckConnect(password, 2);
277  if(ret != SUCCESSED)
278  {
279  return ret;
280  }
281  }
282  else
283  {
284  ret = Clpe_CheckConnect(password, 3);
285  if(ret != SUCCESSED)
286  {
287  return ret;
288  }
289  }
290  }
291 
292  if(!ClpeSocket::create(MCU_ID_MASTER))
293  {
294  return ERROR_CONNECT_CREATE;
295  }
296 
297  if(isAttachedSlave == 1)
298  {
299  if(!ClpeSocket::create(MCU_ID_SLAVE))
300  {
301  return ERROR_CONNECT_CREATE;
302  }
303  }
304 
305  while(1)
306  {
308  if(!ClpeSocket::connect(HOST_MASTER, PORT, MCU_ID_MASTER))
309  {
310  cnt++;
311  }
312  else
313  {
314  errConnect = 0;
315  cnt = 0;
316  break;
317  }
318 
319  if(cnt > 3)
320  {
321  errConnect = 1;
322  cnt = 0;
323  break;
324  }
325 
326  sleep(1);
327  }
328 
329  if(errConnect)
330  {
331  return ERROR_CONNECT_CONNECT;
332  }
333 
334  if(isAttachedSlave == 1)
335  {
336  while(1)
337  {
339  if(!ClpeSocket::connect(HOST_SLAVE, PORT, MCU_ID_SLAVE))
340  {
341  cnt++;
342  }
343  else
344  {
345  errConnect = 0;
346  cnt = 0;
347  break;
348  }
349 
350  if(cnt > 3)
351  {
352  errConnect = 1;
353  cnt = 0;
354  break;
355  }
356 
357  sleep(1);
358  }
359 
360  if(errConnect)
361  {
362  return ERROR_CONNECT_CONNECT;
363  }
364  }
365 
367  system(cmdNet1.c_str());
368  system(cmdNet2.c_str());
369  system(cmdNet3.c_str());
370  system(cmdNet4.c_str());
371  system(cmdNet5.c_str());
372 
373  return SUCCESSED;
374 }
375 
376 int ClpeClientApi::Clpe_Connection()
377 {
378  int ret = 0;
379  int cnt = 0;
380  int errConnect = 0;
381  //int masterCheckedPosition = 0;
382  int isAttachedSlave = 0;
383 
384  //string cmdModule = "echo '" + password + "' | sudo -kS modprobe tegra_vnet > /dev/null 2>&1";
385 
386 
387  //string cmdNet1 = "echo '" + password + "' | sudo -kS sysctl -w net.ipv4.ip_forward=1 > /dev/null 2>&1";
388  //string cmdNet2 = "echo '" + password + "' | sudo -kS sysctl -w net.core.rmem_default=90000000 > /dev/null 2>&1";
389  //string cmdNet3 = "echo '" + password + "' | sudo -kS sysctl -w net.core.rmem_max=90000000 > /dev/null 2>&1";
390  //string cmdNet4 = "echo '" + password + "' | sudo -kS sysctl -w net.ipv4.udp_rmem_min=10000000 > /dev/null 2>&1";
391  //string cmdNet5 = "echo '" + password + "' | sudo -kS sysctl -w net.ipv4.udp_mem='90000000 90000000 90000000' > /dev/null 2>&1";
392 
393  isAttachedSlave = 0; // only support 1 clpe.
394  m_isAttachedSlave = isAttachedSlave;
398  //ret = system(cmdModule.c_str());
399 
400  //if (ret != 0)
401  //{
402  // return ERROR_CONNECT_DRIVER;
403  //}
404 
405  //usleep(500000);
406 
408  //masterCheckedPosition = 0;
409  //ret = Clpe_CheckConnect(password, 0);
410  //if (ret != SUCCESSED)
411  //{
412  // masterCheckedPosition = 1;
413  // ret = Clpe_CheckConnect(password, 1);
414  // if (ret != SUCCESSED)
415  // {
416  // return ret;
417  // }
418  //}
419  //
420 
421  //if (isAttachedSlave == 1)
422  //{
423  // /* Check the connection for slave */
424  // if (masterCheckedPosition == 0)
425  // {
426  // ret = Clpe_CheckConnect(password, 2);
427  // if (ret != SUCCESSED)
428  // {
429  // return ret;
430  // }
431  // }
432  // else
433  // {
434  // ret = Clpe_CheckConnect(password, 3);
435  // if (ret != SUCCESSED)
436  // {
437  // return ret;
438  // }
439  // }
440  //}
441 
442  cnt = 0;
443  int errPing = 0;
444  string cmdPing;
445  string xavierNxIpAddress;
446  xavierNxIpAddress = "192.168.7.7";
447  cmdPing = "ping -c 1 " + xavierNxIpAddress + " -W 1 > /dev/null 2>&1";
448 
449  while (1)
450  {
452  ret = system(cmdPing.c_str());
453 
454  if (ret == 0)
455  {
456  errPing = 0;
457  cnt = 0;
458  break;
459  }
460  else
461  {
462  cnt++;
463  }
464 
465  if (cnt > 3)
466  {
467  errPing = 1;
468  cnt = 0;
469  break;
470  }
471 
472  sleep(1);
473  }
474 
475  if (errPing)
476  {
477  return ERROR_CONNECT_PING;
478  }
479 
480 
481  if (!ClpeSocket::create(MCU_ID_MASTER))
482  {
483  return ERROR_CONNECT_CREATE;
484  }
485 
486  //if (isAttachedSlave == 1)
487  //{
488  // if (!ClpeSocket::create(MCU_ID_SLAVE))
489  // {
490  // return ERROR_CONNECT_CREATE;
491  // }
492  //}
493 
494  cnt = 0;
495  while (1)
496  {
498  if (!ClpeSocket::connect(HOST_MASTER, PORT, MCU_ID_MASTER))
499  {
500  cnt++;
501  }
502  else
503  {
504  errConnect = 0;
505  cnt = 0;
506  break;
507  }
508 
509  if (cnt > 3)
510  {
511  errConnect = 1;
512  cnt = 0;
513  break;
514  }
515 
516  sleep(1);
517  }
518 
519  if (errConnect)
520  {
521  return ERROR_CONNECT_CONNECT;
522  }
523 
524  if (isAttachedSlave == 1)
525  {
526  while (1)
527  {
529  if (!ClpeSocket::connect(HOST_SLAVE, PORT, MCU_ID_SLAVE))
530  {
531  cnt++;
532  }
533  else
534  {
535  errConnect = 0;
536  cnt = 0;
537  break;
538  }
539 
540  if (cnt > 3)
541  {
542  errConnect = 1;
543  cnt = 0;
544  break;
545  }
546 
547  sleep(1);
548  }
549 
550  if (errConnect)
551  {
552  return ERROR_CONNECT_CONNECT;
553  }
554  }
555 
557  //system(cmdNet1.c_str());
558  //system(cmdNet2.c_str());
559  //system(cmdNet3.c_str());
560  //system(cmdNet4.c_str());
561  //system(cmdNet5.c_str());
562 
563  return SUCCESSED;
564 }
565 
566 /********************************************************
567 * Clpe_CheckChrony
568 - Check the chrony time sync between PC and Xavier
569 *********************************************************/
570 int ClpeClientApi::Clpe_CheckTimeSyncStatus()
571 {
572  int ret = 0;
573  int cnt = 0;
574  int errChrony = 0;
575 
576  while(1)
577  {
578  ret = Clpe_TimeSync();
579 
580  if(ret == 0)
581  {
582  errChrony = 0;
583  cnt = 0;
584  break;
585  }
586  else
587  {
588  cnt++;
589  }
590 
591  if(cnt > 4)
592  {
593  errChrony = 1;
594  cnt = 0;
595  break;
596  }
597 
598  sleep(1);
599  }
600 
601  if(errChrony)
602  {
603  return ERROR_CHECK_CHRONY;
604  }
605 
606  return SUCCESSED;
607 }
608 
609 /********************************************************
610 * Clpe_ReqResyncTime
611 - Check the pci device connection between PC and Xavier
612 *********************************************************/
613 int ClpeClientApi::Clpe_ReqResyncTime()
614 {
615  unsigned char *socketTx = (unsigned char*) malloc(SOCKET_CMD_TX_PACKET_SIZE_MAX);
616  unsigned char *socketRx = (unsigned char*) malloc(SOCKET_CMD_RX_PACKET_SIZE_MAX);
617 
618  unsigned int checkSumTx = 0;
619  unsigned int checkSumRx = 0;
620  unsigned int checkSumRxData = 0;
621  unsigned int DataSum = 0;
622 
623  bool ret = false;
624 
625  int returnVal = 0;
626  int sendCmdCnt = 0;
627 
628  if(m_isAttachedSlave == 1)
629  {
630  sendCmdCnt = 2;
631  }
632  else
633  {
634  sendCmdCnt = 1;
635  }
636 
637  for(int cpu_id = 0; cpu_id < sendCmdCnt; cpu_id++)
638  {
639  socketTx[0] = SOCKET_PACKET_ID_PC_TO_XAVIER;
640  socketTx[1] = CMD_ID_REQ_RESYNC_TIME;
641  socketTx[2] = 0x00;
642  checkSumTx = socketTx[0] + socketTx[1] + socketTx[2];
643  socketTx[3] = (unsigned char)((checkSumTx & 0x0000FF00) >> 8);
644  socketTx[4] = (unsigned char)(checkSumTx & 0x000000FF);
645 
646  ret = Clpe_Send(socketTx, cpu_id);
647  if(!ret)
648  {
649  free(socketTx);
650  free(socketRx);
651  return ERROR_GETSET_COMMUNICATION;
652  }
653  ret = Clpe_Recv(socketRx, cpu_id);
654  if(!ret)
655  {
656  free(socketTx);
657  free(socketRx);
658  return ERROR_GETSET_COMMUNICATION;
659  }
660 
661  for(int i = 0; i < SOCKET_CMD_RX_PAYLOAD_SIZE_NORMAL; i++)
662  {
663  DataSum += socketRx[3+i];
664  }
665 
666  checkSumRx = socketRx[0] + socketRx[1] + socketRx[2] + DataSum;
667 
668  checkSumRxData = (unsigned int)(socketRx[11] << 8 | socketRx[12]);
669 
670  if(checkSumRx == checkSumRxData)
671  {
672  if(socketRx[3] == 0)
673  {
674  if(socketRx[4] == 1)
675  {
676  returnVal = SUCCESSED;
677  break;
678  }
679  else
680  {
681  returnVal = ERROR_RESYNC_TIME;
682  break;
683  }
684  }
685  if(socketRx[3] == 1)
686  {
687  returnVal = ERROR_GETSET_COMMAND;
688  break;
689  }
690  if(socketRx[3] == 3)
691  {
692  returnVal = ERROR_GETSET_COMMUNICATION;
693  break;
694  }
695  if(socketRx[3] == 4)
696  {
697  returnVal = ERROR_GETSET_CHECKSUM;
698  break;
699  }
700  }
701  else
702  {
703  returnVal = ERROR_GETSET_CHECKSUM;
704  break;
705  }
706  DataSum = 0;
707 
708  }
709 
710  free(socketTx);
711  free(socketRx);
712 
713  return returnVal;
714 }
715 
716 /********************************************************
717 * Clpe_CheckPci
718 - Check the pci device connection between PC and Xavier
719 *********************************************************/
720 int ClpeClientApi::Clpe_CheckPci()
721 {
722  int ret = 0;
723 
724  ret = system("lspci | grep 'Network controller' | grep 'NVIDIA Corporation Device 2296' > /dev/null 2>&1");
725 
726  if(ret != 0)
727  {
728  return ERROR_CHECK_CONNECT;
729  }
730 
731  return SUCCESSED;
732 }
733 
734 /********************************************************
735  * Clpe_CheckEthernet
736  - Check the ethernet device is up.
737 *********************************************************/
738 int ClpeClientApi::Clpe_CheckNetwork()
739 {
740  int ret = 0;
741 
742  ret = system("ifconfig | grep eth0 | grep 'mtu 64512' > /dev/null 2>&1");
743 
744  if(ret != 0)
745  {
746  return ERROR_CHECK_CONNECT;
747  }
748 
749  if(m_isAttachedSlave == 1)
750  {
751  ret = system("ifconfig | grep eth1 | grep 'mtu 64512' > /dev/null 2>&1");
752  if(ret != 0)
753  {
754  return ERROR_CHECK_CONNECT;
755  }
756  }
757  return SUCCESSED;
758 }
759 
760 /********************************************************
761  * Clpe_CheckPing
762  - Check the ping to Xavier network address
763 *********************************************************/
764 int ClpeClientApi::Clpe_CheckPing()
765 {
766  int ret = 0;
767 
768  ret = system("ping -c 1 192.168.7.7 -W 1 > /dev/null 2>&1");
769 
770  if(ret != 0)
771  {
772  return ERROR_CHECK_CONNECT;
773  }
774 
775  if(m_isAttachedSlave == 1)
776  {
777  ret = system("ping -c 1 192.168.8.7 -W 1 > /dev/null 2>&1");
778  if(ret != 0)
779  {
780  return ERROR_CHECK_CONNECT;
781  }
782  }
783 
784  return SUCCESSED;
785 }
786 
787 /********************************************************
788  * Clpe_TimeSync
789  - Get time sync status between PC and Xavier
790 *********************************************************/
791 int ClpeClientApi::Clpe_TimeSync()
792 {
793  unsigned char *socketTx = (unsigned char*) malloc(SOCKET_CMD_TX_PACKET_SIZE_MAX);
794  unsigned char *socketRx = (unsigned char*) malloc(SOCKET_CMD_RX_PACKET_SIZE_MAX);
795 
796  unsigned int checkSumTx = 0;
797  unsigned int checkSumRx = 0;
798  unsigned int checkSumRxData = 0;
799  unsigned int DataSum = 0;
800 
801  bool ret = false;
802 
803  int returnVal = 0;
804  int sendCmdCnt = 0;
805 
806  if(m_isAttachedSlave == 1)
807  {
808  sendCmdCnt = 2;
809  }
810  else
811  {
812  sendCmdCnt = 1;
813  }
814 
815  for(int cpu_id = 0; cpu_id < sendCmdCnt; cpu_id++)
816  {
817  socketTx[0] = SOCKET_PACKET_ID_PC_TO_XAVIER;
818  socketTx[1] = CMD_ID_SET_TIME_SYNC;
819  socketTx[2] = 0x00;
820  checkSumTx = socketTx[0] + socketTx[1] + socketTx[2];
821  socketTx[3] = (unsigned char)((checkSumTx & 0x0000FF00) >> 8);
822  socketTx[4] = (unsigned char)(checkSumTx & 0x000000FF);
823 
824  ret = Clpe_Send(socketTx, cpu_id);
825  if(!ret)
826  {
827  free(socketTx);
828  free(socketRx);
829  return ERROR_GETSET_COMMUNICATION;
830  }
831  ret = Clpe_Recv(socketRx, cpu_id);
832  if(!ret)
833  {
834  free(socketTx);
835  free(socketRx);
836  return ERROR_GETSET_COMMUNICATION;
837  }
838 
839  for(int i = 0; i < SOCKET_CMD_RX_PAYLOAD_SIZE_NORMAL; i++)
840  {
841  DataSum += socketRx[3+i];
842  }
843 
844  checkSumRx = socketRx[0] + socketRx[1] + socketRx[2] + DataSum;
845 
846  checkSumRxData = (unsigned int)(socketRx[11] << 8 | socketRx[12]);
847 
848  if(checkSumRx == checkSumRxData)
849  {
850  if(socketRx[3] == 0)
851  {
852  if(socketRx[4] == 1)
853  {
854  returnVal = SUCCESSED;
855  break;
856  }
857  else
858  {
859  returnVal = ERROR_GETSET_TIMESYNC;
860  break;
861  }
862  }
863  if(socketRx[3] == 1)
864  {
865  returnVal = ERROR_GETSET_COMMAND;
866  break;
867  }
868  if(socketRx[3] == 3)
869  {
870  returnVal = ERROR_GETSET_COMMUNICATION;
871  break;
872  }
873  if(socketRx[3] == 4)
874  {
875  returnVal = ERROR_GETSET_CHECKSUM;
876  break;
877  }
878  }
879  else
880  {
881  returnVal = ERROR_GETSET_CHECKSUM;
882  break;
883  }
884  DataSum = 0;
885 
886  }
887 
888  free(socketTx);
889  free(socketRx);
890 
891  return returnVal;
892 }
893 
894 /********************************************************
895  * Clpe_StartCam
896  - Start the cam you want to start
897 *********************************************************/
898 int ClpeClientApi::Clpe_StartCam(char use_cam_0, char use_cam_1, char use_cam_2, char use_cam_3, int mcu_id)
899 {
900  unsigned char *socketTx = (unsigned char*) malloc(SOCKET_CMD_TX_PACKET_SIZE_MAX);
901  unsigned char *socketRx = (unsigned char*) malloc(SOCKET_CMD_RX_PACKET_SIZE_MAX);
902 
903  unsigned int checkSumTx = 0;
904  unsigned int checkSumRx = 0;
905  unsigned int checkSumRxData = 0;
906  unsigned int DataSum = 0;
907 
908  bool ret = false;
909 
910  int returnVal = 0;
911 
912  socketTx[0] = SOCKET_PACKET_ID_PC_TO_XAVIER;
913  socketTx[1] = CMD_ID_REQ_START_STREAM;
914 
915  socketTx[2] = 0x00;
916  socketTx[2] = (socketTx[2] << 1) | use_cam_3;
917  socketTx[2] = (socketTx[2] << 1) | use_cam_2;
918  socketTx[2] = (socketTx[2] << 1) | use_cam_1;
919  socketTx[2] = (socketTx[2] << 1) | use_cam_0;
920 
921  checkSumTx = socketTx[0] + socketTx[1] + socketTx[2];
922  socketTx[3] = (unsigned char)((checkSumTx & 0x0000FF00) >> 8);
923  socketTx[4] = (unsigned char)(checkSumTx & 0x000000FF);
924 
925  ret = Clpe_Send(socketTx, mcu_id);
926  if(!ret)
927  {
928  free(socketTx);
929  free(socketRx);
930  return ERROR_GETSET_COMMUNICATION;
931  }
932  ret = Clpe_Recv(socketRx, mcu_id);
933  if(!ret)
934  {
935  free(socketTx);
936  free(socketRx);
937  return ERROR_GETSET_COMMUNICATION;
938  }
939 
940  for(int i = 0; i < SOCKET_CMD_RX_PAYLOAD_SIZE_NORMAL; i++)
941  {
942  DataSum += socketRx[3+i];
943  }
944 
945  checkSumRx = socketRx[0] + socketRx[1] + socketRx[2] + DataSum;
946 
947  checkSumRxData = (unsigned int)(socketRx[11] << 8 | socketRx[12]);
948 
949  if(checkSumRx == checkSumRxData)
950  {
951  if(socketRx[3] == 0)
952  {
953  if(socketRx[4] == 1)
954  {
955  returnVal = SUCCESSED;
956  }
957  else
958  {
959  returnVal = ERROR_GETSET_START;
960  }
961  }
962  if(socketRx[3] == 1)
963  {
964  returnVal = ERROR_GETSET_COMMAND;
965  }
966  if(socketRx[3] == 3)
967  {
968  returnVal = ERROR_GETSET_COMMUNICATION;
969  }
970  if(socketRx[3] == 4)
971  {
972  returnVal = ERROR_GETSET_CHECKSUM;
973  }
974  }
975  else
976  {
977  returnVal = ERROR_GETSET_CHECKSUM;
978  }
979 
980  free(socketTx);
981  free(socketRx);
982 
983  return returnVal;
984 }
985 
986 /********************************************************
987  * Clpe_StopCam
988  - Stop the all of cam
989 *********************************************************/
990 int ClpeClientApi::Clpe_StopCam()
991 {
992  unsigned char *socketTx = (unsigned char*) malloc(SOCKET_CMD_TX_PACKET_SIZE_MAX);
993  unsigned char *socketRx = (unsigned char*) malloc(SOCKET_CMD_RX_PACKET_SIZE_MAX);
994 
995  unsigned int checkSumTx = 0;
996  unsigned int checkSumRx = 0;
997  unsigned int checkSumRxData = 0;
998  unsigned int DataSum = 0;
999 
1000  bool ret = false;
1001 
1002  int returnVal = 0;
1003 
1004  int sendCmdCnt = 0;
1005 
1006  if(m_isAttachedSlave == 1)
1007  {
1008  sendCmdCnt = 2;
1009  }
1010  else
1011  {
1012  sendCmdCnt = 1;
1013  }
1014 
1015  for(int cpu_id = 0; cpu_id < sendCmdCnt; cpu_id++)
1016  {
1017 
1018  socketTx[0] = SOCKET_PACKET_ID_PC_TO_XAVIER;
1019  socketTx[1] = CMD_ID_REQ_STOP_STREAM;
1020  socketTx[2] = 0x00;
1021  checkSumTx = socketTx[0] + socketTx[1] + socketTx[2];
1022  socketTx[3] = (unsigned char)((checkSumTx & 0x0000FF00) >> 8);
1023  socketTx[4] = (unsigned char)(checkSumTx & 0x000000FF);
1024 
1025  ret = Clpe_Send(socketTx, cpu_id);
1026  if(!ret)
1027  {
1028  free(socketTx);
1029  free(socketRx);
1030  return ERROR_GETSET_COMMUNICATION;
1031  }
1032  ret = Clpe_Recv(socketRx, cpu_id);
1033  if(!ret)
1034  {
1035  free(socketTx);
1036  free(socketRx);
1037  return ERROR_GETSET_COMMUNICATION;
1038  }
1039 
1040  for(int i = 0; i < SOCKET_CMD_RX_PAYLOAD_SIZE_NORMAL; i++)
1041  {
1042  DataSum += socketRx[3+i];
1043  }
1044 
1045  checkSumRx = socketRx[0] + socketRx[1] + socketRx[2] + DataSum;
1046 
1047  checkSumRxData = (unsigned int)(socketRx[11] << 8 | socketRx[12]);
1048 
1049  if(checkSumRx == checkSumRxData)
1050  {
1051  if(socketRx[3] == 0)
1052  {
1053  if(socketRx[4] == 1)
1054  {
1055  returnVal = SUCCESSED;
1056  }
1057  else
1058  {
1059  returnVal = ERROR_GETSET_STOP;
1060  break;
1061  }
1062  }
1063  if(socketRx[3] == 1)
1064  {
1065  returnVal = ERROR_GETSET_COMMAND;
1066  break;
1067  }
1068  if(socketRx[3] == 3)
1069  {
1070  returnVal = ERROR_GETSET_COMMUNICATION;
1071  break;
1072  }
1073  if(socketRx[3] == 4)
1074  {
1075  returnVal = ERROR_GETSET_CHECKSUM;
1076  break;
1077  }
1078  }
1079  else
1080  {
1081  returnVal = ERROR_GETSET_CHECKSUM;
1082  break;
1083  }
1084  DataSum = 0;
1085  }
1086 
1087  free(socketTx);
1088  free(socketRx);
1089 
1090  return returnVal;
1091 }
1092 
1093 /********************************************************
1094  * Clpe_GetMicomVersion
1095  - Get Version of Micom
1096 *********************************************************/
1097 int ClpeClientApi::Clpe_GetMicomVersion(unsigned char* version_master)
1098 {
1099  unsigned char *socketTx = (unsigned char*) malloc(SOCKET_CMD_TX_PACKET_SIZE_MAX);
1100  unsigned char *socketRx = (unsigned char*) malloc(SOCKET_CMD_RX_PACKET_SIZE_MAX);
1101 
1102  unsigned int checkSumTx = 0;
1103  unsigned int checkSumRx = 0;
1104  unsigned int checkSumRxData = 0;
1105  unsigned int DataSum = 0;
1106  unsigned char *version;
1107 
1108  bool ret = false;
1109 
1110  int returnVal = 0;
1111 
1112  int sendCmdCnt = 0;
1113 
1114  if(m_isAttachedSlave == 1)
1115  {
1116  sendCmdCnt = 2;
1117  }
1118  else
1119  {
1120  sendCmdCnt = 1;
1121  }
1122 
1123  for(int cpu_id = 0; cpu_id < sendCmdCnt; cpu_id++)
1124  {
1125  if(cpu_id == MCU_ID_MASTER)
1126  {
1127  version = version_master;
1128  }
1129  else
1130  {
1131  //version = version_slave;
1132  free(socketTx);
1133  free(socketRx);
1134  return ERROR_INVALID_MCU_ID;
1135  }
1136  socketTx[0] = SOCKET_PACKET_ID_PC_TO_XAVIER;
1137  socketTx[1] = CMD_ID_GET_MICOM_FIRM_VERSION;
1138  socketTx[2] = 0x00;
1139  checkSumTx = socketTx[0] + socketTx[1] + socketTx[2];
1140  socketTx[3] = (unsigned char)((checkSumTx & 0x0000FF00) >> 8);
1141  socketTx[4] = (unsigned char)(checkSumTx & 0x000000FF);
1142 
1143  ret = Clpe_Send(socketTx, cpu_id);
1144  if(!ret)
1145  {
1146  free(socketTx);
1147  free(socketRx);
1148  return ERROR_GETSET_COMMUNICATION;
1149  }
1150  ret = Clpe_Recv(socketRx, cpu_id);
1151  if(!ret)
1152  {
1153  free(socketTx);
1154  free(socketRx);
1155  return ERROR_GETSET_COMMUNICATION;
1156  }
1157 
1158  for(int i = 0; i < SOCKET_CMD_RX_PAYLOAD_SIZE_NORMAL; i++)
1159  {
1160  DataSum += socketRx[3+i];
1161  }
1162 
1163  checkSumRx = socketRx[0] + socketRx[1] + socketRx[2] + DataSum;
1164 
1165  checkSumRxData = (unsigned int)(socketRx[11] << 8 | socketRx[12]);
1166 
1167  if(checkSumRx == checkSumRxData)
1168  {
1169  if(socketRx[3] == 0)
1170  {
1171  for(int i = 0; i < 6; i++)
1172  {
1173  version[i] = socketRx[4+i];
1174  }
1175  returnVal = SUCCESSED;
1176  }
1177  if(socketRx[3] == 1)
1178  {
1179  returnVal = ERROR_GETSET_COMMAND;
1180  break;
1181  }
1182  if(socketRx[3] == 3)
1183  {
1184  returnVal = ERROR_GETSET_COMMUNICATION;
1185  break;
1186  }
1187  }
1188  else
1189  {
1190  returnVal = ERROR_GETSET_CHECKSUM;
1191  break;
1192  }
1193  DataSum = 0;
1194  }
1195 
1196  free(socketTx);
1197  free(socketRx);
1198 
1199  return returnVal;
1200 }
1201 
1202 /********************************************************
1203  * Clpe_GetXavierVersion
1204  - Get Version of Xavier
1205 *********************************************************/
1206 int ClpeClientApi::Clpe_GetXavierVersion(unsigned char* version_master)
1207 {
1208  unsigned char *socketTx = (unsigned char*) malloc(SOCKET_CMD_TX_PACKET_SIZE_MAX);
1209  unsigned char *socketRx = (unsigned char*) malloc(SOCKET_CMD_RX_PACKET_SIZE_MAX);
1210 
1211  unsigned int checkSumTx = 0;
1212  unsigned int checkSumRx = 0;
1213  unsigned int checkSumRxData = 0;
1214  unsigned int DataSum = 0;
1215  unsigned char *version;
1216 
1217  bool ret = false;
1218 
1219  int returnVal = 0;
1220 
1221  int sendCmdCnt = 0;
1222 
1223  if(m_isAttachedSlave == 1)
1224  {
1225  sendCmdCnt = 2;
1226  }
1227  else
1228  {
1229  sendCmdCnt = 1;
1230  }
1231 
1232  for(int cpu_id = 0; cpu_id < sendCmdCnt; cpu_id++)
1233  {
1234  if(cpu_id == MCU_ID_MASTER)
1235  {
1236  version = version_master;
1237  }
1238  else
1239  {
1240  //version = version_slave;
1241  free(socketTx);
1242  free(socketRx);
1243  return ERROR_INVALID_MCU_ID;
1244  }
1245  socketTx[0] = SOCKET_PACKET_ID_PC_TO_XAVIER;
1246  socketTx[1] = CMD_ID_GET_XAVIER_VERSION;
1247  socketTx[2] = 0x00;
1248  checkSumTx = socketTx[0] + socketTx[1] + socketTx[2];
1249  socketTx[3] = (unsigned char)((checkSumTx & 0x0000FF00) >> 8);
1250  socketTx[4] = (unsigned char)(checkSumTx & 0x000000FF);
1251 
1252  ret = Clpe_Send(socketTx, cpu_id);
1253  if(!ret)
1254  {
1255  free(socketTx);
1256  free(socketRx);
1257  return ERROR_GETSET_COMMUNICATION;
1258  }
1259  ret = Clpe_Recv(socketRx, cpu_id);
1260  if(!ret)
1261  {
1262  free(socketTx);
1263  free(socketRx);
1264  return ERROR_GETSET_COMMUNICATION;
1265  }
1266 
1267  for(int i = 0; i < SOCKET_CMD_RX_PAYLOAD_SIZE_NORMAL; i++)
1268  {
1269  DataSum += socketRx[3+i];
1270  }
1271 
1272  checkSumRx = socketRx[0] + socketRx[1] + socketRx[2] + DataSum;
1273 
1274  checkSumRxData = (unsigned int)(socketRx[11] << 8 | socketRx[12]);
1275 
1276  if(checkSumRx == checkSumRxData)
1277  {
1278  if(socketRx[3] == 0)
1279  {
1280  for(int i = 0; i < (SOCKET_CMD_RX_PAYLOAD_SIZE_NORMAL - 2); i++)
1281  {
1282  version[i] = socketRx[4+i];
1283  }
1284  returnVal = SUCCESSED;
1285  }
1286  if(socketRx[3] == 1)
1287  {
1288  returnVal = ERROR_GETSET_COMMAND;
1289  break;
1290  }
1291  if(socketRx[3] == 3)
1292  {
1293  returnVal = ERROR_GETSET_COMMUNICATION;
1294  break;
1295  }
1296  }
1297  else
1298  {
1299  returnVal = ERROR_GETSET_CHECKSUM;
1300  break;
1301  }
1302  DataSum = 0;
1303  }
1304 
1305  free(socketTx);
1306  free(socketRx);
1307 
1308  return returnVal;
1309 }
1310 
1311 /********************************************************
1312  * Clpe_GetSDKVersion
1313  - Get Version of SDK
1314 *********************************************************/
1315 int ClpeClientApi::Clpe_GetSDKVersion(unsigned char* version)
1316 {
1317  int returnVal = SUCCESSED;
1318 
1319  memcpy(version, sdkVersion, 6);
1320 
1321  return returnVal;
1322 }
1323 
1324 /********************************************************
1325  * Clpe_GetCamStatus
1326  - Get Lock Status of Camera
1327 *********************************************************/
1328 int ClpeClientApi::Clpe_GetCamStatus(int* status)
1329 {
1330  unsigned char *socketTx = (unsigned char*) malloc(SOCKET_CMD_TX_PACKET_SIZE_MAX);
1331  unsigned char *socketRx = (unsigned char*) malloc(SOCKET_CMD_RX_PACKET_SIZE_MAX);
1332  //unsigned char socketRx[13] = {0, };
1333 
1334  unsigned int checkSumTx = 0;
1335  unsigned int checkSumRx = 0;
1336  unsigned int checkSumRxData = 0;
1337  unsigned int DataSum = 0;
1338 
1339  bool ret = false;
1340 
1341  int returnVal = 0;
1342 
1343  int sendCmdCnt = 0;
1344 
1345  if(m_isAttachedSlave == 1)
1346  {
1347  sendCmdCnt = 2;
1348  }
1349  else
1350  {
1351  sendCmdCnt = 1;
1352  }
1353 
1354  for(int cpu_id = 0; cpu_id < sendCmdCnt; cpu_id++)
1355  {
1356  socketTx[0] = SOCKET_PACKET_ID_PC_TO_XAVIER;
1357  socketTx[1] = CMD_ID_GET_SER_LOCK_STAUS;
1358  socketTx[2] = 0x00;
1359  checkSumTx = socketTx[0] + socketTx[1] + socketTx[2];
1360  socketTx[3] = (unsigned char)((checkSumTx & 0x0000FF00) >> 8);
1361  socketTx[4] = (unsigned char)(checkSumTx & 0x000000FF);
1362 
1363  ret = Clpe_Send(socketTx, cpu_id);
1364  if(!ret)
1365  {
1366  free(socketTx);
1367  free(socketRx);
1368  return ERROR_GETSET_COMMUNICATION;
1369  }
1370  ret = Clpe_Recv(socketRx, cpu_id);
1371  if(!ret)
1372  {
1373  free(socketTx);
1374  free(socketRx);
1375  return ERROR_GETSET_COMMUNICATION;
1376  }
1377 
1378  for(int i = 0; i < SOCKET_CMD_RX_PAYLOAD_SIZE_NORMAL; i++)
1379  {
1380  DataSum += socketRx[3+i];
1381  }
1382 
1383  checkSumRx = socketRx[0] + socketRx[1] + socketRx[2] + DataSum;
1384 
1385  checkSumRxData = (unsigned int)(socketRx[11] << 8 | socketRx[12]);
1386 
1387  if(checkSumRx == checkSumRxData)
1388  {
1389  if(socketRx[3] == 0)
1390  {
1391  for(int i = 0; i < MAX_CAMERA_CNT_PER_BOARD; i++)
1392  {
1393  status[i + (cpu_id * MAX_CAMERA_CNT_PER_BOARD)] = (int)socketRx[4+i];
1394  }
1395  returnVal = SUCCESSED;
1396  }
1397  if(socketRx[3] == 1)
1398  {
1399  returnVal = ERROR_GETSET_COMMAND;
1400  break;
1401  }
1402  if(socketRx[3] == 3)
1403  {
1404  returnVal = ERROR_GETSET_COMMUNICATION;
1405  break;
1406  }
1407  }
1408  else
1409  {
1410  returnVal = ERROR_GETSET_CHECKSUM;
1411  break;
1412  }
1413  DataSum = 0;
1414  }
1415  free(socketTx);
1416  free(socketRx);
1417 
1418  return returnVal;
1419 }
1420 
1421 /********************************************************
1422  * Clpe_SetXavierPowerOff
1423  - Set Power Off the Xavier Server
1424 *********************************************************/
1425 int ClpeClientApi::Clpe_SetXavierPowerOff()
1426 {
1427  unsigned char *socketTx = (unsigned char*) malloc(6);
1428  unsigned char *socketRx = (unsigned char*) malloc(13);
1429 
1430  unsigned int checkSumTx = 0;
1431  unsigned int checkSumRx = 0;
1432  unsigned int checkSumRxData = 0;
1433  unsigned int DataSum = 0;
1434 
1435  bool ret = false;
1436 
1437  int returnVal = 0;
1438 
1439  int sendCmdCnt = 0;
1440 
1441  if(m_isAttachedSlave == 1)
1442  {
1443  sendCmdCnt = 2;
1444  }
1445  else
1446  {
1447  sendCmdCnt = 1;
1448  }
1449 
1450  for(int cpu_id = 0; cpu_id < sendCmdCnt; cpu_id++)
1451  {
1452  socketTx[0] = SOCKET_PACKET_ID_PC_TO_XAVIER;
1453  socketTx[1] = CMD_ID_REQ_POWER_OFF;
1454  socketTx[2] = 0x00;
1455  checkSumTx = socketTx[0] + socketTx[1] + socketTx[2];
1456  socketTx[3] = (unsigned char)((checkSumTx & 0x0000FF00) >> 8);
1457  socketTx[4] = (unsigned char)(checkSumTx & 0x000000FF);
1458 
1459  ret = Clpe_Send(socketTx, cpu_id);
1460  if(!ret)
1461  {
1462  free(socketTx);
1463  free(socketRx);
1464  return ERROR_GETSET_COMMUNICATION;
1465  }
1466  ret = Clpe_Recv(socketRx, cpu_id);
1467  if(!ret)
1468  {
1469  free(socketTx);
1470  free(socketRx);
1471  return ERROR_GETSET_COMMUNICATION;
1472  }
1473 
1474  for(int i = 0; i < SOCKET_CMD_RX_PAYLOAD_SIZE_NORMAL; i++)
1475  {
1476  DataSum += socketRx[3+i];
1477  }
1478 
1479  checkSumRx = socketRx[0] + socketRx[1] + socketRx[2] + DataSum;
1480 
1481  checkSumRxData = (unsigned int)(socketRx[11] << 8 | socketRx[12]);
1482 
1483  if(checkSumRx == checkSumRxData)
1484  {
1485  if(socketRx[3] == 0)
1486  {
1487  returnVal = SUCCESSED;
1488  }
1489  if(socketRx[3] == 1)
1490  {
1491  returnVal = ERROR_GETSET_COMMAND;
1492  break;
1493  }
1494  if(socketRx[3] == 3)
1495  {
1496  returnVal = ERROR_GETSET_COMMUNICATION;
1497  break;
1498  }
1499  }
1500  else
1501  {
1502  returnVal = ERROR_GETSET_CHECKSUM;
1503  break;
1504  }
1505  DataSum = 0;
1506  }
1507 
1508  free(socketTx);
1509  free(socketRx);
1510 
1511  return returnVal;
1512 }
1513 
1514 /********************************************************
1515  * Clpe_StartStream
1516  - Start stream cam you want to stream
1517 *********************************************************/
1518 int ClpeClientApi::Clpe_StartStream(T_CB_APP cb_app, int use_cam_0, int use_cam_1,
1519  int use_cam_2, int use_cam_3, int display_on)
1520 {
1521  int ret = 0;
1522  int returnVal = 0;
1523 
1524  int sendCmdCnt = 0;
1525 
1526  if(m_isAttachedSlave == 1)
1527  {
1528  sendCmdCnt = 2;
1529  }
1530  else
1531  {
1532  sendCmdCnt = 1;
1533  }
1534 
1535  for(int cpu_id = 0; cpu_id < sendCmdCnt; cpu_id++)
1536  {
1537  if(cpu_id == MCU_ID_MASTER)
1538  {
1539  ret = Clpe_StartCam((char)use_cam_1, (char)use_cam_0, (char)use_cam_3, (char)use_cam_2, cpu_id);
1540  }
1541  else
1542  {
1543  //ret = Clpe_StartCam((char)use_cam_5, (char)use_cam_4, (char)use_cam_7, (char)use_cam_6, cpu_id);
1544  return ERROR_INVALID_MCU_ID;
1545  }
1546  }
1547 
1548  sleep(2);
1549 
1550  if(ret == 0)
1551  {
1552  returnVal = clpe_startStream(cb_app, (char)use_cam_1, (char)use_cam_0, (char)use_cam_3, (char)use_cam_2, display_on);
1553  }
1554  else
1555  {
1556  returnVal = ERROR_START_STREAM;
1557  }
1558 
1559  return returnVal;
1560 }
1561 
1562 /********************************************************
1563  * Clpe_StopStream
1564  - Stop stream all the cam
1565 *********************************************************/
1566 int ClpeClientApi::Clpe_StopStream()
1567 {
1568  int ret = 0;
1569  int returnVal = 0;
1570 
1571  ret = Clpe_StopCam();
1572 
1573  if(ret == 0)
1574  {
1575  returnVal = clpe_stopStream();
1576  }
1577  else
1578  {
1579  returnVal = ERROR_STOP_STREAM;
1580  }
1581 
1582  return returnVal;
1583 }
1584 
1585 /********************************************************
1586  * Clpe_GetFrameAllCam
1587  - Get frame from all of streaming cam
1588 *********************************************************/
1589 int ClpeClientApi::Clpe_GetFrameAllCam(int *p_camera_id, unsigned char **p_buffer, unsigned int *p_size, struct timeval *pt_camera_timeStamp)
1590 {
1591  int returnVal = 0;
1592 
1593  returnVal = clpe_getFrameAnyCam(p_camera_id, p_buffer, p_size, pt_camera_timeStamp);
1594 
1595  int temp = 0;
1596  temp = *p_camera_id;
1597  temp %= 2;
1598 
1599  switch (temp)
1600  {
1601  case 0:
1602  ++*p_camera_id;
1603  break;
1604  case 1:
1605  --*p_camera_id;
1606  break;
1607  }
1608 
1609  return returnVal;
1610 }
1611 
1612 /********************************************************
1613  * Clpe_GetFrameOneCam
1614  - Get frame from one of streaming cam you choose
1615 *********************************************************/
1616 int ClpeClientApi::Clpe_GetFrameOneCam(int camera_id, unsigned char **p_buffer, unsigned int *p_size, struct timeval *pt_camera_timeStamp)
1617 {
1618  int returnVal = 0;
1619 
1620  int temp = 0;
1621  temp = camera_id;
1622  temp %= 2;
1623 
1624  switch (temp)
1625  {
1626  case 0:
1627  ++camera_id;
1628  break;
1629  case 1:
1630  --camera_id;
1631  break;
1632  }
1633 
1634  returnVal = clpe_getFrameWithCamId(camera_id, p_buffer, p_size, pt_camera_timeStamp);
1635 
1636  return returnVal;
1637 }
1638 
CMD_ID_REQ_RESYNC_TIME
#define CMD_ID_REQ_RESYNC_TIME
Definition: ClpeGlobalDef.h:37
ERROR_RESYNC_TIME
#define ERROR_RESYNC_TIME
Definition: ClpeClientApi.h:25
ClpeClientApi::Clpe_GetXavierVersion
int Clpe_GetXavierVersion(unsigned char *version_master)
Definition: ClpeClientApi.cpp:1206
ClpeClientApi::Clpe_SetXavierPowerOff
int Clpe_SetXavierPowerOff()
Definition: ClpeClientApi.cpp:1425
ClpeClientApi::Clpe_GetCamStatus
int Clpe_GetCamStatus(int *status)
Definition: ClpeClientApi.cpp:1328
T_CB_APP
int(* T_CB_APP)(unsigned int inst, unsigned char *buffer, unsigned int size, struct timeval *frame_us)
Definition: ClpeStreamApi.h:10
MCU_ID_SLAVE
#define MCU_ID_SLAVE
Definition: ClpeGlobalDef.h:51
SUCCESSED
#define SUCCESSED
Definition: ClpeClientApi.h:15
ERROR_GETSET_TIMESYNC
#define ERROR_GETSET_TIMESYNC
Definition: ClpeClientApi.h:21
ClpeClientApi::Clpe_CheckConnect
int Clpe_CheckConnect(string password, int settingValue)
Definition: ClpeClientApi.cpp:68
ClpeSocket::recv
bool recv(unsigned char *s, int mcu_id) const
Definition: ClpeSocket.cpp:223
clpe_getFrameAnyCam
int clpe_getFrameAnyCam(int *p_camera_id, unsigned char **p_buffer, unsigned int *p_size, struct timeval *pt_camera_timeStamp)
Definition: ClpeStream.cpp:619
ERROR_CONNECT_NETWORK
#define ERROR_CONNECT_NETWORK
Definition: ClpeClientApi.h:28
CMD_ID_SET_TIME_SYNC
#define CMD_ID_SET_TIME_SYNC
Definition: ClpeGlobalDef.h:32
ClpeClientApi::Clpe_CheckNetwork
int Clpe_CheckNetwork()
Definition: ClpeClientApi.cpp:738
ClpeSocket::connect
bool connect(const string host, const int port, int mcu_id)
Definition: ClpeSocket.cpp:268
ClpeClientApi::Clpe_TimeSync
int Clpe_TimeSync()
Definition: ClpeClientApi.cpp:791
CMD_ID_GET_SER_LOCK_STAUS
#define CMD_ID_GET_SER_LOCK_STAUS
Definition: ClpeGlobalDef.h:25
CMD_ID_REQ_STOP_STREAM
#define CMD_ID_REQ_STOP_STREAM
Definition: ClpeGlobalDef.h:34
ERROR_CHECK_CONNECT
#define ERROR_CHECK_CONNECT
Definition: ClpeClientApi.h:36
clpe_stopStream
int clpe_stopStream(void)
Definition: ClpeStream.cpp:599
clpe_startStream
int clpe_startStream(T_CB_APP cb_app, char use_cam_0, char use_cam_1, char use_cam_2, char use_cam_3, int display_on)
Definition: ClpeStream.cpp:574
clpe_getFrameWithCamId
int clpe_getFrameWithCamId(int camera_id, unsigned char **p_buffer, unsigned int *p_size, struct timeval *pt_camera_timeStamp)
Definition: ClpeStream.cpp:645
HOST_SLAVE
#define HOST_SLAVE
Definition: ClpeClientApi.h:12
ClpeClientApi::Clpe_GetFrameOneCam
int Clpe_GetFrameOneCam(int camera_id, unsigned char **p_buffer, unsigned int *p_size, struct timeval *pt_camera_timeStamp)
Definition: ClpeClientApi.cpp:1616
HOST_MASTER
#define HOST_MASTER
Definition: ClpeClientApi.h:11
ClpeClientApi::Clpe_StopStream
int Clpe_StopStream()
Definition: ClpeClientApi.cpp:1566
ERROR_CONNECT_DRIVER
#define ERROR_CONNECT_DRIVER
Definition: ClpeClientApi.h:27
ClpeClientApi::Clpe_CheckPing
int Clpe_CheckPing()
Definition: ClpeClientApi.cpp:764
ClpeClientApi::Clpe_CheckPci
int Clpe_CheckPci()
Definition: ClpeClientApi.cpp:720
ClpeClientApi::Clpe_GetMicomVersion
int Clpe_GetMicomVersion(unsigned char *version_master)
Definition: ClpeClientApi.cpp:1097
ERROR_CHECK_CHRONY
#define ERROR_CHECK_CHRONY
Definition: ClpeClientApi.h:34
ClpeClientApi::Clpe_StopCam
int Clpe_StopCam()
Definition: ClpeClientApi.cpp:990
ERROR_GETSET_CHECKSUM
#define ERROR_GETSET_CHECKSUM
Definition: ClpeClientApi.h:20
CMD_ID_GET_MICOM_FIRM_VERSION
#define CMD_ID_GET_MICOM_FIRM_VERSION
Definition: ClpeGlobalDef.h:26
ClpeGlobalDef.h
ClpeSDKVersion.h
ClpeClientApi::Clpe_GetFrameAllCam
int Clpe_GetFrameAllCam(int *p_camera_id, unsigned char **p_buffer, unsigned int *p_size, struct timeval *pt_camera_timeStamp)
Definition: ClpeClientApi.cpp:1589
ClpeClientApi::Clpe_StartCam
int Clpe_StartCam(char use_cam_0, char use_cam_1, char use_cam_2, char use_cam_3, int mcu_id)
Definition: ClpeClientApi.cpp:898
MCU_ID_MASTER
#define MCU_ID_MASTER
Definition: ClpeGlobalDef.h:50
SOCKET_CMD_RX_PAYLOAD_SIZE_NORMAL
#define SOCKET_CMD_RX_PAYLOAD_SIZE_NORMAL
Definition: ClpeGlobalDef.h:45
ClpeClientApi::Clpe_Connection
int Clpe_Connection()
Definition: ClpeClientApi.cpp:376
CMD_ID_REQ_START_STREAM
#define CMD_ID_REQ_START_STREAM
Definition: ClpeGlobalDef.h:33
ERROR_START_STREAM
#define ERROR_START_STREAM
Definition: ClpeClientApi.h:38
ERROR_GETSET_START
#define ERROR_GETSET_START
Definition: ClpeClientApi.h:22
ClpeSocket::close
void close(int mcu_id)
Definition: ClpeSocket.cpp:341
PORT
#define PORT
Definition: ClpeClientApi.h:13
ClpeClientApi::m_isAttachedSlave
int m_isAttachedSlave
Definition: ClpeClientApi.h:80
CMD_ID_REQ_POWER_OFF
#define CMD_ID_REQ_POWER_OFF
Definition: ClpeGlobalDef.h:27
ERROR_INVALID_MCU_ID
#define ERROR_INVALID_MCU_ID
Definition: ClpeClientApi.h:24
ERROR_GETSET_COMMUNICATION
#define ERROR_GETSET_COMMUNICATION
Definition: ClpeClientApi.h:19
ERROR_CONNECT_ADDRESS
#define ERROR_CONNECT_ADDRESS
Definition: ClpeClientApi.h:29
ERROR_CONNECT_CREATE
#define ERROR_CONNECT_CREATE
Definition: ClpeClientApi.h:31
ERROR_GETSET_STOP
#define ERROR_GETSET_STOP
Definition: ClpeClientApi.h:23
ERROR_STOP_STREAM
#define ERROR_STOP_STREAM
Definition: ClpeClientApi.h:39
ClpeClientApi::Clpe_GetSDKVersion
int Clpe_GetSDKVersion(unsigned char *version)
Definition: ClpeClientApi.cpp:1315
ERROR_CONNECT_PING
#define ERROR_CONNECT_PING
Definition: ClpeClientApi.h:30
ClpeClientApi::Clpe_ReqResyncTime
int Clpe_ReqResyncTime()
Definition: ClpeClientApi.cpp:613
ClpeClientApi.h
SOCKET_CMD_TX_PACKET_SIZE_MAX
#define SOCKET_CMD_TX_PACKET_SIZE_MAX
Definition: ClpeGlobalDef.h:44
SOCKET_CMD_RX_PACKET_SIZE_MAX
#define SOCKET_CMD_RX_PACKET_SIZE_MAX
Definition: ClpeGlobalDef.h:48
ClpeClientApi::Clpe_CheckTimeSyncStatus
int Clpe_CheckTimeSyncStatus()
Definition: ClpeClientApi.cpp:570
CMD_ID_GET_XAVIER_VERSION
#define CMD_ID_GET_XAVIER_VERSION
Definition: ClpeGlobalDef.h:31
sdkVersion
const unsigned char sdkVersion[7]
Definition: ClpeSDKVersion.h:5
ClpeClientApi::Clpe_Recv
bool Clpe_Recv(unsigned char *s, int mcu_id)
Definition: ClpeClientApi.cpp:52
ClpeClientApi::~ClpeClientApi
virtual ~ClpeClientApi()
Definition: ClpeClientApi.cpp:23
SOCKET_PACKET_ID_PC_TO_XAVIER
#define SOCKET_PACKET_ID_PC_TO_XAVIER
Definition: ClpeGlobalDef.h:10
ClpeSocket::create
bool create(int mcu_id)
Definition: ClpeSocket.cpp:30
ClpeSocket::send
bool send(unsigned char *s, int mcu_id) const
Definition: ClpeSocket.cpp:192
ERROR_CONNECT_CONNECT
#define ERROR_CONNECT_CONNECT
Definition: ClpeClientApi.h:32
ERROR_GETSET_COMMAND
#define ERROR_GETSET_COMMAND
Definition: ClpeClientApi.h:17
ClpeClientApi::Clpe_StartStream
int Clpe_StartStream(T_CB_APP cb_app, int use_cam_0, int use_cam_1, int use_cam_2, int use_cam_3, int display_on)
Definition: ClpeClientApi.cpp:1518
MAX_CAMERA_CNT_PER_BOARD
#define MAX_CAMERA_CNT_PER_BOARD
Definition: ClpeClientApi.cpp:10
ClpeClientApi::ClpeClientApi
ClpeClientApi()
Definition: ClpeClientApi.cpp:15
ClpeClientApi::Clpe_Send
bool Clpe_Send(unsigned char *s, int mcu_id)
Definition: ClpeClientApi.cpp:36

clpe_sdk
Author(s): Can-lab Corporation
autogenerated on Wed Oct 12 2022 02:17:28