polaris.h

Go to the documentation of this file.

/*=======================================================================

  Program:   NDI Combined API C Interface Library
  Module:    $RCSfile: polaris.h,v $
  Creator:   David Gobbi <dgobbi@atamai.com>
  Language:  C++
  Author:    $Author: dgobbi $
  Date:      $Date: 2005/07/01 22:52:05 $
  Version:   $Revision: 1.2 $

==========================================================================

Copyright (c) 2000-2005 Atamai, Inc.

Use, modification and redistribution of the software, in source or
binary forms, are permitted provided that the following terms and
conditions are met:

1) Redistribution of the source code, in verbatim or modified
   form, must retain the above copyright notice, this license,
   the following disclaimer, and any notices that refer to this
   license and/or the following disclaimer.  

2) Redistribution in binary form must include the above copyright
   notice, a copy of this license and the following disclaimer
   in the documentation or with other materials provided with the
   distribution.

3) Modified copies of the source code must be clearly marked as such,
   and must not be misrepresented as verbatim copies of the source code.

THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE SOFTWARE "AS IS"
WITHOUT EXPRESSED OR IMPLIED WARRANTY INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  IN NO EVENT SHALL ANY COPYRIGHT HOLDER OR OTHER PARTY WHO MAY
MODIFY AND/OR REDISTRIBUTE THE SOFTWARE UNDER THE TERMS OF THIS LICENSE
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, LOSS OF DATA OR DATA BECOMING INACCURATE
OR LOSS OF PROFIT OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF
THE USE OR INABILITY TO USE THE SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

=======================================================================*/

#ifndef POLARIS_H
#define POLARIS_H 1

#define POLARIS_MAJOR_VERSION 3
#define POLARIS_MINOR_VERSION 2

#include "PlusConfigure.h"

#include "ndicapi.h"

#ifdef __cplusplus
extern "C" {
#endif

#include <stdarg.h>
#include <stdio.h>
#include <string.h>

typedef struct ndicapi polaris;

/*=====================================================================*/
static char *plDeviceName(int i) { return ndiDeviceName(i); }

static int plProbe(const char *device) { return ndiProbe(device); }

static polaris *plOpen(const char *device) { return ndiOpen(device); }

static void plClose(polaris *pol) { ndiClose(pol); }

static void plSetThreadMode(polaris *pol, int mode) { ndiSetThreadMode(pol,mode); }

static char *plCommand(polaris *pol, const char *format, ...) {
  char *reply; va_list ap; va_start(ap,format);
  reply = ndiCommandVA(pol, format, ap); va_end(ap); return reply; }

static char *plCommandVA(polaris *pol, const char *format, va_list ap) {
  return ndiCommandVA(pol, format, ap); }

typedef NDIErrorCallback PLErrorCallback;

static void plSetErrorCallback(polaris *pol,
                               PLErrorCallback callback,
                               void *userdata) {
  ndiSetErrorCallback(pol, callback, userdata); }

/*=====================================================================*/
/*\{*/
#define plRESET(p) plCommand((p),NULL)

#define plINIT(p) plCommand((p),"INIT:")

#define plCOMM(p,baud,dps,h) plCommand((p),"COMM:%d%03d%d",(baud),(dps),(h))

#define plPVWR(p,port,a,x) plCommand((p),"PVWR:%c%04X%.128s",(port),(a),(x))

#define plPVCLR(p,port) plCommand((p),"PVCLR:%c",(port))

#define plPINIT(p,port) plCommand((p),"PINIT:%c",(port))

#define plPENA(p,port,mode) plCommand((p),"PENA:%c%c",(port),(mode))

#define plPDIS(p,port) plCommand((p),"PDIS:%c",(port))

#define plTSTART(p) plCommand((p),"TSTART:")

#define plTSTOP(p) plCommand((p),"TSTOP:")

#define plGX(p,mode) plCommand((p),"GX:%04X",(mode))

#define plLED(p,port,led,s) plCommand((p),"LED:%c%d%c",(port),(led),(s))

#define plBEEP(p,n) plCommand((p),"BEEP:%i",(n))

#define plVER(p,n) plCommand((p),"VER:%d",(n))

#define plSFLIST(p,mode) plCommand((p),"SFLIST:%02X",(mode))

#define plVSEL(p,n) plCommand((p),"VSEL:%d",(n))

#define plPSTAT(p,format) plCommand((p),"PSTAT:%04X",(format))

#define plSSTAT(p,format) plCommand((p),"SSTAT:%04X",(format))

#define plPPRD(p,port,addr) plCommand((p),"PPRD:%c%04X",(port),(addr))

#define plPPWR(p,port,a,x) plCommand((p),"PPWR:%c%04X%.128s",(port),(a),(x))

#define plPURD(p,port,addr) plCommand((p),"PURD:%c%04X",(port),(addr))

#define plPUWR(p,port,a,x) plCommand((p),"PPWR:%c%04X%.128s",(port),(a),(x))

#define plPSEL(p,port,id) plCommand((p),"PSEL:%c%s",(port),(id))

#define plPSRCH(p,port) plCommand((p),"PSRCH:%c",(port))

#define plPVTIP(p,port,tip,np) plCommand((p),"PVTIP:%c%d%d",(port),(tip),(np))

#define plTTCFG(p,port) plCommand((p),"TTCFG:%c",(port))

#define plTCTST(p,port) plCommand((p),"TCTST:%c",(port))

#define plDSTART(p) plCommand((p),"DSTART:")

#define plDSTOP(p) plCommand((p),"DSTOP:")

#define plIRINIT(p) plCommand((p),"IRINIT:")

#define plIRCHK(p,mode) plCommand((p),"IRCHK:%04X",(mode))

#define plIRED(p,port,sig) plCommand((p),"IRED:%c%08X",(port),(sig))

#define pl3D(p,port,mode) plCommand((p),"3D:%c%d",(port),(mode))

static int plPVWRFromFile(polaris *pol, int port, char *filename) {
  unsigned char buffer[1024];
  char hexdata[128];
  FILE *file=NULL;
  int addr;

  errno_t err = fopen_s (&file,filename, "rb"); 
  if( err != 0)
  {
    LOG_ERROR("Error opening file: " << filename << " Error No.: " << err); 
    return -1;
  } 

  memset(buffer, 0, 1024);      /* clear buffer to zero */
  fread(buffer, 1, 1024, file); /* read at most 1k from file */
  if (ferror(file)) {
    fclose(file);
    return -1;
  }
  fclose(file);

  for (addr = 0; addr < 1024; addr += 64) { /* write in chunks of 64 bytes */
    plPVWR(pol, port, addr, ndiHexEncode(hexdata, &buffer[addr], 64));
    if (ndiGetError(pol) != NDI_OKAY) {
      return -1;
    }
  }
 
  return 0;
}
/*\}*/

/*=====================================================================*/
static int plGetError(polaris *pol) { return ndiGetError(pol); }

static char *plGetDeviceName(polaris *pol) { return ndiGetDeviceName(pol); }

typedef NDIFileHandle PLFileHandle;

static PLFileHandle plGetDeviceHandle(polaris *pol) { return ndiGetDeviceHandle(pol); }

static int plGetThreadMode(polaris *pol) { return ndiGetThreadMode(pol); }

static int plGetGXTransform(polaris *pol, int port, double transform[8]) {
  return ndiGetGXTransform(pol, port, transform); }

static int plGetGXPortStatus(polaris *pol, int port) {
  return ndiGetGXPortStatus(pol, port); }

static int plGetGXSystemStatus(polaris *pol) {
  return ndiGetGXSystemStatus(pol); }

static int plGetGXToolInfo(polaris *pol, int port) {
  return ndiGetGXToolInfo(pol, port); }

static int plGetGXMarkerInfo(polaris *pol, int port, int marker) {
  return ndiGetGXMarkerInfo(pol, port, marker); }

static int plGetGXSingleStray(polaris *pol, int port, double coord[3]) {
  return ndiGetGXSingleStray(pol, port, coord); }

static unsigned long plGetGXFrame(polaris *pol, int port) {
  return ndiGetGXFrame(pol, port); }

static int plGetGXNumberOfPassiveStrays(polaris *pol) {
  return ndiGetGXNumberOfPassiveStrays(pol); }

static int plGetGXPassiveStray(polaris *pol, int i, double coord[3]) {
  return ndiGetGXPassiveStray(pol, i, coord); }

static int plGetPSTATPortStatus(polaris *pol, int port) {
  return ndiGetPSTATPortStatus(pol, port); }

static int plGetPSTATToolInfo(polaris *pol, int port, char information[30]) {
  return ndiGetPSTATToolInfo(pol, port, information); }

static unsigned long plGetPSTATCurrentTest(polaris *pol, int port) {
  return ndiGetPSTATCurrentTest(pol, port); }

static int plGetPSTATPartNumber(polaris *pol, int port, char part[20]) {
  return ndiGetPSTATPartNumber(pol, port, part); }

static int plGetPSTATAccessories(polaris *pol, int port) {
  return plGetPSTATAccessories(pol, port); }

static int plGetPSTATMarkerType(polaris *pol, int port) {
  return ndiGetPSTATMarkerType(pol, port); }

static int plGetSSTATControl(polaris *pol) {
  return ndiGetSSTATControl(pol); }

static int plGetSSTATSensors(polaris *pol) {
  return ndiGetSSTATSensors(pol); }

static int plGetSSTATTIU(polaris *pol) {
  return ndiGetSSTATTIU(pol); }

static int plGetIRCHKDetected(polaris *pol) {
  return ndiGetIRCHKDetected(pol); }

static int plGetIRCHKNumberOfSources(polaris *pol, int side) {
  return ndiGetIRCHKNumberOfSources(pol, side); }

static int plGetIRCHKSourceXY(polaris *pol, int side, int i, double xy[2]) {
  return ndiGetIRCHKSourceXY(pol, side, i, xy); }

/*=====================================================================*/
static char *plErrorString(int errnum) {
  return ndiErrorString(errnum); }

static unsigned long plHexToUnsignedLong(const char *cp, int n) {
  return ndiHexToUnsignedLong(cp, n); }

static long plSignedToLong(const char *cp, int n) {
  return ndiSignedToLong(cp, n); }

static char *plHexEncode(char *cp, const void *data, int n) {
  return ndiHexEncode(cp, data, n); }

static void *plHexDecode(void *data, const char *cp, int n) {
  return ndiHexDecode(data, cp, n); }

/*=====================================================================*/
/*\{*/
#define PL_OKAY            0x00  
#define PL_INVALID         0x01  
#define PL_TOO_LONG        0x02  
#define PL_TOO_SHORT       0x03  
#define PL_BAD_COMMAND_CRC 0x04  
#define PL_INTERN_TIMEOUT  0x05  
#define PL_COMM_FAIL       0x06  
#define PL_PARAMETERS      0x07  
#define PL_INVALID_PORT    0x08  
#define PL_INVALID_MODE    0x09  
#define PL_INVALID_LED     0x0a  
#define PL_LED_STATE       0x0b  
#define PL_BAD_MODE        0x0c  
#define PL_NO_TOOL         0x0d  
#define PL_PORT_NOT_INIT   0x0e  
#define PL_PORT_DISABLED   0x0f  
#define PL_INITIALIZATION  0x10  
#define PL_TSTOP_FAIL      0x11  
#define PL_TSTART_FAIL     0x12  
#define PL_PINIT_FAIL      0x13  
#define PL_CAMERA          0x14  
#define PL_INIT_FAIL       0x15  
#define PL_DSTART_FAIL     0x16  
#define PL_DSTOP_FAIL      0x17  
#define PL_IRCHK_FAIL      0x18  
#define PL_FIRMWARE        0x19  
#define PL_INTERNAL        0x1a  
#define PL_IRINIT_FAIL     0x1b 
#define PL_IRED_FAIL       0x1c  
#define PL_SROM_FAIL       0x1d  
#define PL_SROM_READ       0x1e  
#define PL_SROM_WRITE      0x1f  
#define PL_SROM_SELECT     0x20  
#define PL_PORT_CURRENT    0x21  
#define PL_WAVELENGTH      0x22 
#define PL_PARAMETER_RANGE 0x23  
#define PL_VOLUME          0x24  
#define PL_FEATURES        0x25  
#define PL_ENVIRONMENT     0xf1  
#define PL_EPROM_READ      0xf6  
#define PL_EPROM_WRITE     0xf5  
#define PL_EPROM_ERASE     0xf4  
/* error codes returned by the C api */

#define PL_BAD_CRC         0x0100  
#define PL_OPEN_ERROR      0x0200  
#define PL_BAD_COMM        0x0300  
#define PL_TIMEOUT         0x0400  
#define PL_WRITE_ERROR     0x0500  
#define PL_READ_ERROR      0x0600  
#define PL_RESET_FAIL      0x0700  
#define PL_PROBE_FAIL      0x0800  
/*\}*/


/* plCOMM() baud rates */
/*\{*/
#define  PL_9600     0          
#define  PL_14400    1 
#define  PL_19200    2
#define  PL_38400    3
#define  PL_57600    4
#define  PL_115200   5
/*\}*/

/* plCOMM() data bits, parity and stop bits */
/*\{*/
#define  PL_8N1      0              /* 8 data bits, no parity, 1 stop bit */
#define  PL_8N2      1              /* etc. */
#define  PL_8O1     10
#define  PL_8O2     11
#define  PL_8E1     20
#define  PL_8E2     21
#define  PL_7N1    100
#define  PL_7N2    101
#define  PL_7O1    110
#define  PL_7O2    111
#define  PL_7E1    120
#define  PL_7E2    121 
/*\}*/

/* plCOMM() hardware handshaking */
/*\{*/
#define  PL_NOHANDSHAKE  0
#define  PL_HANDSHAKE    1
/*\}*/

/* plPENA() tracking modes */
/*\{*/
#define  PL_STATIC      'S'    /* relatively immobile tool */ 
#define  PL_DYNAMIC     'D'    /* dynamic tool (e.g. probe) */
#define  PL_BUTTON_BOX  'B'    /* tool with no IREDs */
/*\}*/

/* plGX() reply mode bit definitions */
/*\{*/
#define  PL_XFORMS_AND_STATUS  0x0001  /* transforms and status */
#define  PL_ADDITIONAL_INFO    0x0002  /* additional tool transform info */
#define  PL_SINGLE_STRAY       0x0004  /* stray active marker reporting */
#define  PL_FRAME_NUMBER       0x0008  /* frame number for each tool */
#define  PL_PASSIVE            0x8000  /* report passive tool information */
#define  PL_PASSIVE_EXTRA      0x2000  /* add 6 extra passive tools */
#define  PL_PASSIVE_STRAY      0x1000  /* stray passive marker reporting */
/*\}*/

/* return values that give the reason behind missing data */
/*\{*/
#define PL_DISABLED        1  
#define PL_MISSING         2  
#define PL_UNOCCUPIED      3
/*\}*/

/* plGetGXPortStatus() and plGetPSTATPortStatus() return value bits */
/*\{*/
#define  PL_TOOL_IN_PORT        0x01
#define  PL_SWITCH_1_ON         0x02
#define  PL_SWITCH_2_ON         0x04
#define  PL_SWITCH_3_ON         0x08
#define  PL_INITIALIZED         0x10
#define  PL_ENABLED             0x20
#define  PL_OUT_OF_VOLUME       0x40 /* only for plGetGXPortStatus() */
#define  PL_PARTIALLY_IN_VOLUME 0x80 /* only for plGetGXPortStatus() */ 
#define  PL_CURRENT_DETECT      0x80 /* only for plGetPSTATPortStatus() */
/*\}*/

/* plGetGXSystemStatus() return value bits */
/*\{*/
#define  PL_COMM_SYNC_ERROR            0x01
#define  PL_TOO_MUCH_EXTERNAL_INFRARED 0x02
#define  PL_COMM_CRC_ERROR             0x04
/*\}*/

/* plGetGXToolInfo() return value bits */
/*\{*/
#define  PL_BAD_TRANSFORM_FIT   0x01
#define  PL_NOT_ENOUGH_MARKERS  0x02
#define  PL_TOOL_FACE_USED      0x70
/*\}*/

/* plGetGXMarkerInfo() return value bits */
/*\{*/
#define  PL_MARKER_MISSING             0
#define  PL_MARKER_EXCEEDED_MAX_ANGLE  1
#define  PL_MARKER_EXCEEDED_MAX_ERROR  2
#define  PL_MARKER_USED                3
/*\}*/

/* plLED() states */
/*\{*/
#define  PL_BLANK 'B'    /* off */
#define  PL_FLASH 'F'    /* flashing */
#define  PL_SOLID 'S'    /* on */
/*\}*/

/* plPSTAT() reply mode bits */
/*\{*/
#define  PL_BASIC           0x0001
#define  PL_TESTING         0x0002
#define  PL_PART_NUMBER     0x0004
#define  PL_ACCESSORIES     0x0008
#define  PL_MARKER_TYPE     0x0010
/*\}*/

/* plGetPSTATAccessories() return value bits */
/*\{*/
#define  PL_TOOL_IN_PORT_SWITCH   0x01  /* tool has tool-in-port switch */
#define  PL_SWITCH_1              0x02  /* tool has button #1 */
#define  PL_SWITCH_2              0x04  /* tool has button #2 */
#define  PL_SWITCH_3              0x08  /* tool has button #3 */
#define  PL_TOOL_TRACKING_LED     0x10  /* tool has tracking LED */
#define  PL_LED_1                 0x20  /* tool has LED #1 */
#define  PL_LED_2                 0x40  /* tool has LED #2 */
#define  PL_LED_3                 0x80  /* tool has LED #3 */
/*\}*/
  
/* plGetPSTATMarkerType() return value, the first 3 bits */
/*\{*/
#define PL_950NM            0x00
#define PL_850NM            0x01
/*\}*/

/* plGetPSTATMarkerType() return value, the last 5 bits */
/*\{*/
#define PL_NDI_ACTIVE       0x08
#define PL_NDI_CERAMIC      0x10
#define PL_PASSIVE_ANY      0x20
#define PL_PASSIVE_SPHERE   0x28
#define PL_PASSIVE_DISC     0x30
/*\}*/

/* plSSTAT() reply format bits */
/*\{*/
#define PL_CONTROL         0x0001  /* control processor information */
#define PL_SENSORS         0x0002  /* sensor processors */
#define PL_TIU             0x0004  /* TIU processor */
/*\}*/

/* plGetSSTATControl() return value bits */
/*\{*/
#define PL_EPROM_CODE_CHECKSUM     0x01
#define PL_EPROM_SYSTEM_CHECKSUM   0x02
/*\}*/

/* plGetSSTATSensor() return value bits */
/*\{*/
#define PL_LEFT_ROM_CHECKSUM   0x01
#define PL_LEFT_SYNC_TYPE_1    0x02
#define PL_LEFT_SYNC_TYPE_2    0x04
#define PL_RIGHT_ROM_CHECKSUM  0x10
#define PL_RIGHT_SYNC_TYPE_1   0x20
#define PL_RIGHT_SYNC_TYPE_2   0x40
/*\}*/

/* plGetSSTATTIU() return value bits */
/*\{*/
#define PL_ROM_CHECKSUM        0x01
#define PL_OPERATING_VOLTAGES  0x02
#define PL_MARKER_SEQUENCING   0x04
#define PL_SYNC                0x08
#define PL_COOLING_FAN         0x10
#define PL_INTERNAL_ERROR      0x20
/*\}*/

/* plIRCHK() reply mode bits */
/*\{*/
#define  PL_DETECTED   0x0001   /* simple yes/no whether IR detected */
#define  PL_SOURCES    0x0002   /* locations of up to 20 sources per camera */
/*\}*/

/* plGetIRCHKNumberOfSources(), plGetIRCHKSourceXY() sensor arguments */
/*\{*/
#define  PL_LEFT   0            /* left sensor */
#define  PL_RIGHT  1            /* right sensor */
/*\}*/

#ifdef __cplusplus
}
#endif

#endif /* POLARIS_H */