C++ (Cpp) clGetSerialPortIdentifier Examples

Example #1

File: clSerial.cpp Project: Ryuk4/crappy

void Camera::serialInit(unsigned int serialIndex){
  try
  { 
    unsigned int * numSerialPorts;
    numSerialPorts = (unsigned int *) malloc(32);

    char *portID= NULL;
    unsigned int bufferSize= 512;
    portID = (char *) malloc(bufferSize);

    if (clSerialInit(serialIndex, &serialRefPtr) == CL_ERR_PORT_IN_USE or clSerialInit(serialIndex, &serialRefPtr) == CL_ERR_INVALID_INDEX)
      return;
    serialRefPtr = (void*) malloc(10);
    if (clSerialInit(serialIndex, &serialRefPtr)  == CL_ERR_NO_ERR)
      printf("PORT %d IS OPENED\n", serialIndex);
    
    char *buf = NULL;
    unsigned int buflen = 10;
    if (clGetSerialPortIdentifier(serialIndex, buf, &buflen) != CL_ERR_BUFFER_TOO_SMALL)
      return;
    
    buf = (char*) malloc (buflen);
    if (clGetSerialPortIdentifier(serialIndex, buf, &buflen) == CL_ERR_NO_ERR)
      printf("port %i is identified as %s\n", serialIndex, buf);
    
    free(buf);
  }
  
  catch (exception& e)
  {
    cout << "An exception occurred. Exception: " << e.what() << '\n';
  }
}

Example #2

File: Cpco_cl_com.cpp Project: ndyann/Guider

DWORD CPco_cl_com::Open_Cam_Ext(DWORD num,SC2_OpenStruct *open)
{
  int err;

  initmode=num & ~0xFF;
  num=num&0xFF;

  if(num>PCO_SC2_DRIVER_ENTRY_SIZE)
  {
   writelog(ERROR_M,(PCO_HANDLE)1,"Open_Cam_Ext: No more entries left return NODRIVER");
   return PCO_ERROR_DRIVER_NODRIVER | PCO_ERROR_DRIVER_CAMERALINK;
  }

  if(connected&(1<<num))
  {
   writelog(ERROR_M,(PCO_HANDLE)1,"Open_Cam_Ext: camera is already connected");
   return PCO_ERROR_DRIVER_NODRIVER | PCO_ERROR_DRIVER_CAMERALINK;
  }

  hdriver=(void*)(0x100+num);
  camerarev=0;

  tab_timeout.command=PCO_SC2_COMMAND_TIMEOUT;
  tab_timeout.image=PCO_SC2_IMAGE_TIMEOUT_L;
  tab_timeout.transfer=PCO_SC2_COMMAND_TIMEOUT;

  transferpar.baudrate=9600;
  transferpar.DataFormat=PCO_CL_DATAFORMAT_5x12;

  unsigned int num_port=0;
  {
   char manufacturerName[500];
   unsigned int bufferSize;
   unsigned int version;
   char type[500];
   unsigned int buffersize;

   bufferSize=sizeof(manufacturerName);
   buffersize=sizeof(type);

//   if(clGetNumSerialPorts)
   {
    clGetNumSerialPorts(&num_port);
    if(num>=num_port)
    {
     hdriver=NULL;
     writelog(ERROR_M,(PCO_HANDLE)1,"Open_Cam_Ext: board %d reqested, only %d ports found return NODRIVER",num,num_port);
	    return PCO_ERROR_DRIVER_NODRIVER | PCO_ERROR_DRIVER_CAMERALINK;
    }
   }
//   if(clGetManufacturerInfo)
   {
    clGetManufacturerInfo(manufacturerName,&bufferSize,&version);
    writelog(INIT_M,(PCO_HANDLE)1,"Open_Cam_Ext: ManufacturerName %s",manufacturerName);
   }

//   if(clGetSerialPortIdentifier)
   {
    for(unsigned int i=0;i<num_port;i++)
    {
     clGetSerialPortIdentifier(i,type,&buffersize);
     writelog(INIT_M,(PCO_HANDLE)1,"Open_Cam_Ext: PortIdentifier %d: %s",i,type);
    }
   }
  }

  err=clSerialInit(num,(void**)&serialRef);
  if(err<0)
  {
   writelog(ERROR_M,(PCO_HANDLE)1,"Open_Cam_Ext: Cannot open serial Cameralink Device %d %d",num,err);
   hdriver=NULL;
   serialRef=NULL;
   return PCO_ERROR_DRIVER_NODRIVER | PCO_ERROR_DRIVER_CAMERALINK;
  }

  boardnr=num;

//check if camera is connected, error should be timeout
//get camera descriptor to get maximal size of ccd
//scan for other baudrates than default 9600baud
  SC2_Simple_Telegram com;
  err=PCO_NOERROR;

  err=scan_camera();
  if(err!=PCO_NOERROR)
  {
   writelog(ERROR_M,hdriver,"Open_Cam_Ext: Control command failed with 0x%x, no camera connected",err);

   clSerialClose(serialRef);

   boardnr=-1;
   hdriver=NULL;
   serialRef=NULL;

   return PCO_ERROR_DRIVER_NOTINIT  | PCO_ERROR_DRIVER_CAMERALINK;
  }

  com.wCode=GET_CAMERA_DESCRIPTION;
  com.wSize=sizeof(SC2_Simple_Telegram);
  err=Control_Command(&com,sizeof(com),
                      &description,sizeof(SC2_Camera_Description_Response));

  if(err!=PCO_NOERROR)
   writelog(ERROR_M,hdriver,"Open_Cam_Ext: GET_CAMERA_DESCRIPTION failed with 0x%x",err);

  get_actual_cl_config();
  get_firmwarerev();
  get_lut_info();


  char evname[25];
  sprintf(evname,"%s%d",COM_MUTEX_NAME,num);
/*
  hComMutex=CreateMutex(NULL,FALSE,evname);
  int e=GetLastError();
  writelog(INIT_M,hdriver,"Open_Cam_Ext: Mutex 0x%x name %s created",hComMutex,evname);
  hComMutex=CreateMutex(NULL,FALSE,NULL);
  writelog(INIT_M,hdriver,"Open_Cam_Ext: GetLastError returned %d",e);
*/

  if(transferpar.baudrate!=115200)
   set_baudrate(115200);

  connected|=(1<<boardnr);

  return PCO_NOERROR;
}