pvcam.h

SDFGASFASFASFAS EDGSGA DGSFGSA

  rs_bool rotate;           /* TRUE=Rotate the data during export            */
  rs_bool x_flip;           /* TRUE=Flip the data horizontally during export */
  rs_bool y_flip;           /* TRUE=Flip the data vertically during export   */
  int16 precision;          /* Bits in output data, see constants            */
  int16 windowing;          /* See list of constants                         */
  int32 max_inten;          /* Highest intensity, if windowing               */
  int32 min_inten;          /* Lowest intensity, if windowing                */
  int16 output_x_size;      /* Controls output array size                    */
  int16 output_y_size;      /* Controls output array size                    */
}
export_ctrl_type, PV_PTR_DECL export_ctrl_ptr;
typedef const export_ctrl_type PV_PTR_DECL export_ctrl_const_ptr;



/************************** Classless Entries       **************************/
enum TIME_UNITS
{
  TU_DAY    = 10,	
  TU_HOUR   = 5,
  TU_MINUTE = 4,
  TU_SEC    = 3,
  TU_MSEC   = 2,      /* millisecond  */
  TU_USEC   = 1,      /* microsecond  */
  TU_NSEC   = 7,      /* nanosecond   */
  TU_PSEC   = 8,      /* picosecond   */
  TU_FSEC   = 9       /* femtosecond  */
};







/**************************** Function Prototypes ****************************/
#ifdef PV_C_PLUS_PLUS
extern "C"
{
#endif


/*****************************************************************************/
/*****************************************************************************/
/*                                                                           */
/*             Class 0: Camera Communications Function Prototypes            */
/*                                                                           */
/*****************************************************************************/
/*****************************************************************************/

/*****************************************************************************/
/* rs_bool (RETURN)  All functions that return a rs_bool return TRUE for     */
/*                   success and FALSE for failure.  If a failure occurs     */
/*                   pl_error_code() and pl_error_message() can be used to   */
/*                   determine the cause.                                    */
/*****************************************************************************/

/*****************************************************************************/
/* pvcam_version     Version number of the PVCAM library                     */
/*                     16 bits = MMMMMMMMrrrrTTTT where MMMMMMMM = Major #,  */
/*                     rrrr = Minor #, and TTTT = Trivial #                  */
/*****************************************************************************/

  rs_bool PV_DECL pl_pvcam_get_ver (uns16_ptr pvcam_version);
  rs_bool PV_DECL pl_pvcam_init (void);
  rs_bool PV_DECL pl_pvcam_uninit (void);

/*****************************************************************************/
/* hcam              Camera handle returned from pl_cam_open()               */
/* cam_num           Camera number Range: 0 through (totl_cams-1)            */
/* camera_name       Text name assigned to a camera (with RSConfig)          */
/* totl_cams         Total number of cameras in the system                   */
/* o_mode            Mode to open the camera in (must be OPEN_EXCLUSIVE)     */
/*****************************************************************************/

  rs_bool PV_DECL pl_cam_check (int16 hcam);
  rs_bool PV_DECL pl_cam_close (int16 hcam);
  rs_bool PV_DECL pl_cam_get_diags (int16 hcam);
  rs_bool PV_DECL pl_cam_get_name (int16 cam_num, char_ptr camera_name);
  rs_bool PV_DECL pl_cam_get_total (int16_ptr totl_cams);
  rs_bool PV_DECL pl_cam_open (char_ptr camera_name, int16_ptr hcam,
                               int16 o_mode);

/*****************************************************************************/
/* ddi_version       Device Driver Interface version number                  */
/*                   (The 16 bits are MMMMMMMMnnnnTTTT)                      */
/*                   where MMMMMMMM = Major number, nnnn = Minor number, and */
/*                   TTTT = Trivial number                                   */
/*****************************************************************************/

  rs_bool PV_DECL pl_ddi_get_ver (uns16_ptr ddi_version);


/*****************************************************************************/
/*****************************************************************************/
/*                                                                           */
/*                Class 1: Error Reporting Function Prototypes               */
/*                                                                           */
/*****************************************************************************/
/*****************************************************************************/

/*****************************************************************************/
/* int16 (RETURN)    pl_error_code(void) returns the error code of the last  */
/*                   pl_ function call.                                      */
/* err_code          Unique ID of the error: returned from pl_error_code()   */
/* msg               Text description of err_code.                           */
/*****************************************************************************/

  int16   PV_DECL pl_error_code (void);
  rs_bool PV_DECL pl_error_message (int16 err_code, char_ptr msg);


/*****************************************************************************/
/*****************************************************************************/
/*                                                                           */
/*              Class 2: Configuration/Setup Function Prototypes             */
/*                                                                           */
/*****************************************************************************/
/*****************************************************************************/

/*****************************************************************************/
/* param_id          ID of the parameter to get or set (PARAM_...)           */
/* param_attribute   Attribute of the parameter to get (ATTR_...)            */
/* param_value       Value to get or set                                     */
/* index             Index of enumeration Range: 0 through N-1 ... where N   */
/*                     is retrieved with get_param(...,ATTR_COUNT,...)       */
/* value             Numerical value of enumeration                          */
/* desc              Text description of enumeration                         */
/* length            Length of text description of enumeration               */
/*****************************************************************************/

  rs_bool PV_DECL pl_get_param (int16 hcam, uns32 param_id,
                                int16 param_attribute, void_ptr param_value);
  rs_bool PV_DECL pl_set_param (int16 hcam, uns32 param_id,
                                void_ptr param_value);
  rs_bool PV_DECL pl_get_enum_param (int16 hcam, uns32 param_id, uns32 index,
                                     int32_ptr value, char_ptr desc,
                                     uns32 length);
  rs_bool PV_DECL pl_enum_str_length (int16 hcam, uns32 param_id, uns32 index,
                                      uns32_ptr length);

/*****************************************************************************/
/*****************************************************************************/
/*                                                                           */
/*               Class 3: Data Acquisition Function Prototypes               */
/*                                                                           */
/*****************************************************************************/
/*****************************************************************************/

/*****************************************************************************/
/* pixel_stream      Buffer to hold image(s)                                 */
/* byte_cnt          Size of bufer to hold images (in bytes)                 */
/* exp_total         Total number of exposures to take                       */
/* rgn_total         Total number of regions defined for each image          */
/* rgn_array         Array of regions (must be rgn_total in size)            */
/*                     s1    starting pixel in the serial register           */
/*                     s2    ending pixel in the serial register             */
/*                     sbin  serial binning for this region                  */
/*                     p1    starting pixel in the parallel register         */
/*                     p2    ending pixel in the parallel register           */
/*                     pbin  parallel binning for this region                */
/* exp_mode          Mode for capture (TIMED_MODE, STROBED_MODE, ...)        */
/* exposure_time     Time to expose in selected exposure resolution          */
/*                     Default is milliseconds (see PARAM_EXP_RES)           */
/* exp_bytes         Value returned from PVCAM specifying the required       */
/*                     number of bytes to allocate for the capture           */
/* buffer_mode       Circular buffer mode (CIRC_OVERWRITE,...)               */
/* size              Size of continuous capture pixel_stream                 */
/*                     (must be a multiple of byte_cnt)                      */
/* status            Status of the current capture (EXPOSURE_IN_PROGRESS,...)*/
/* bytes_arrived     Number of bytes that have arrived.  For continuous      */
/*                     mode this is the number of bytes that have arrived    */
/*                     this time through the buffer.                         */
/* buffer_cnt        Number of times through the buffer (continuous mode)    */
/* frame             Pointer to the requested image                          */
/* cam_state         State to set the camera in (CCS_NO_CHANGE,...)          */
/* hbuf              Standard image buffer                                   */
/* exposure          Exposure # to unravel, 65535 for All, else exposure #   */
/* array_list        Array of Pointers that will get the unraveled images    */
/*                     in the same order as the regions.                     */
/* tlimit            Time in milliseconds to wait for a transfer             */
/*****************************************************************************/

  rs_bool PV_DECL pl_exp_init_seq (void);
  rs_bool PV_DECL pl_exp_uninit_seq (void);
  rs_bool PV_DECL pl_exp_get_driver_buffer (int16 hcam,
                                            void_ptr_ptr pixel_stream,
                                            uns32_ptr byte_cnt);
  rs_bool PV_DECL pl_exp_setup_seq (int16 hcam, uns16 exp_total,
                                    uns16 rgn_total, rgn_const_ptr rgn_array,
                                    int16 exp_mode, uns32 exposure_time,
                                    uns32_ptr exp_bytes);
  rs_bool PV_DECL pl_exp_start_seq (int16 hcam, void_ptr pixel_stream);
  rs_bool PV_DECL pl_exp_setup_cont (int16 hcam, uns16 rgn_total,
                                     rgn_const_ptr rgn_array, int16 exp_mode,
                                     uns32 exposure_time, uns32_ptr exp_bytes,
                                     int16 buffer_mode);
  rs_bool PV_DECL pl_exp_start_cont (int16 hcam, void_ptr pixel_stream,
                                     uns32 size);
  rs_bool PV_DECL pl_exp_check_status (int16 hcam, int16_ptr status,
                                       uns32_ptr bytes_arrived);
  rs_bool PV_DECL pl_exp_check_cont_status (int16 hcam, int16_ptr status,
                                            uns32_ptr bytes_arrived,
                                            uns32_ptr buffer_cnt);
  rs_bool PV_DECL pl_exp_get_latest_frame (int16 hcam, void_ptr_ptr frame);
  rs_bool PV_DECL pl_exp_get_oldest_frame (int16 hcam, void_ptr_ptr frame);
  rs_bool PV_DECL pl_exp_unlock_oldest_frame (int16 hcam);
  rs_bool PV_DECL pl_exp_stop_cont (int16 hcam, int16 cam_state);
  rs_bool PV_DECL pl_exp_abort (int16 hcam, int16 cam_state);
  rs_bool PV_DECL pl_exp_finish_seq (int16 hcam, void_ptr pixel_stream,
                                     int16 hbuf);
  rs_bool PV_DECL pl_exp_unravel (int16 hcam, uns16 exposure,
                                  void_ptr pixel_stream, uns16 rgn_total,
                                  rgn_const_ptr rgn_array,
                                  uns16_ptr * array_list);
  rs_bool PV_DECL pl_exp_wait_start_xfer (int16 hcam, uns32 tlimit);
  rs_bool PV_DECL pl_exp_wait_end_xfer (int16 hcam, uns32 tlimit);

/*****************************************************************************/
/* addr              Specifies which I/O address to control                  */
/* state             Specifies the value to write to the register            */
/* location          Specifies when to control the I/O (SCR_PRE_FLASH,...)   */
/*****************************************************************************/

  rs_bool PV_DECL pl_io_script_control (int16 hcam, uns16 addr, flt64 state,
                                        uns32 location);
  rs_bool PV_DECL pl_io_clear_script_control (int16 hcam);

/*****************************************************************************/
/*****************************************************************************/
/*                                                                           */
/*             Class 4: Buffer Manipulation Function Prototypes              */
/*                                                                           */
/*****************************************************************************/