Página principal   Lista alfabética   Lista de componentes   Lista de archivos   Miembros de las clases   Archivos de los miembros  

ptu.cpp

Ir a la documentación de este archivo.
00001 /*************************************************************************
00002 *****                  PTU BINARY DRIVER CODE FILE                   ****/
00003 #define PTU_CPI_CODE_VERSION   "v1.09.10"
00004 /****                                                                *****
00005 *****             (C)1995-1999, Directed Perception, Inc.            *****
00006 *****                     All Rights Reserved.                       *****
00007 *****                                                                *****
00008 *****   Licensed users may freely distribute compiled code including *****
00009 *****   this code and data. Source data and code may NOT be          *****
00010 *****   distributed without the prior written consent from           *****
00011 *****   Directed Perception, Inc.                                    *****
00012 *****           Directed Perception, Inc. reserves the right to make *****
00013 *****   changes without further notice to any content herein to      *****
00014 *****   improve reliability, function or design. Directed Perception *****
00015 *****   shall not assume any liability arising from the application  *****
00016 *****   or use of this code, data or function.                       *****
00017 *****                                                                *****
00018 **************************************************************************
00019 
00020 CHANGE HISTORY:
00021     8/18/99: v1.09.10    Select_unit_ID binary opcode code added and commented
00022                          for users wishing to user binary unit selects (i.e.,
00023                          by uncommenting the binary op and commenting out the ASCII op).
00024     7/28/99: v1.09.09r2  In firmware_version_OK, made sure it works even when
00025                          the controller is in feedback terse mode. Also added 
00026                          10 sec timeout on read to allow fall-out from non-responsive PTU.
00027     5/12/99: v1.09.09r1  select_unit declarations cleaned up
00028     2/ 8/99: v1.09.09.   select_unit operation performed using ASCII select to aid
00029                          debugging for developers.
00030     1/26/99: v1.09.08.   select_unit was blocking for a getchar that doesn't happen...
00031     9/23/98: v1.09.07.   Added additional commands supported in firmware version v1.9.7
00032                          and above. Unit commands modified to work (unsigned short int).
00033     8/10/98: v1.08.09.   In firmware_version_OK, removed addressing to string constant.
00034     9/27/97: v1.08.08.   Win32. Removed writestring in openserial.
00035                          Set 0 read timeout in setserial. Peek improved.
00036     7/10/97: v1.08.00.   Firmware version check modified so illegal version
00037                          numbers (e.g., from bad read operations) are detected
00038     11/2/95:  v1.07.07d. Firmware version check bug fixed.
00039     7/11/95:  v1.07.06d. Updated opcode structure and added new support.
00040     2/19/95:  v1.07.04d. Generalized for Windows, DOS, & UNIX.
00041                          Added networking. 
00042     10/12/94: v1.07.03d. Pre-release working version.
00043                          XON/XOFF removed from PTU firmware to allow for binary mode.
00044 
00045 
00046 **************************************************************************/
00047 
00048 #define PTU_OPCODE_VERSION                                      "v1.07.07d"
00049 /* this code supports controller firmware versions equal or above */
00050 #define PTU_modelVersion                                                1
00051 #define PTU_codeVersion                                                 7
00052 #define PTU_revision                                                    6
00053 
00054 /* The binary PTU driver code */
00055 /* Assumes serial support for read_byte and write_byte */
00056 
00057 /* #include <windows.h> */
00058 
00059 
00060 /* #include <dos.h>   */
00061 /* #include <conio.h> */
00062 #include <stdio.h>         
00063 #include <ctype.h>
00064 #include <string.h>
00065 /* #include <stdlib.h> */
00066 /* #include <time.h>   */
00067 /* #include <dir.h>    */
00068 #ifdef _UNIX
00069 #include "../include/ptu.h"
00070 #else
00071 #include "ptu.h"
00072 #endif
00073 
00074 static char err;
00075 
00076 static portstream_fd current_host_port;
00077 
00078 static char speed_control_mode = PTU_INDEPENDENT_SPEED_CONTROL_MODE;
00079 
00080 
00081 /* open_host_port(<portname>) ==> <portstream> */
00082 portstream_fd open_host_port(char *portname)
00083 {  current_host_port = openserial(portname);
00084    return current_host_port;
00085 }
00086 
00087 
00088 /* close_host_port(<portstream>) ==> <status> */
00089 char close_host_port(portstream_fd portstream)
00090         {   current_host_port = PORT_NOT_OPENED;
00091             return( closeserial(portstream) );
00092         }
00093 
00094 
00095 unsigned char GetSerialChar(char await_char)
00096         {  unsigned char c;
00097 
00098                 for (;;) {
00099                         err = SerialBytesIn(current_host_port, &c, 1, -1);
00100                         if (err < 0) return err;
00101                         else if (err > 0) return c;
00102                                   else if (await_char != TRUE)
00103                                                          return 0;
00104                         }
00105         }
00106 
00107 char SerialOut(unsigned char outchar)
00108 {    return SerialBytesOut(current_host_port, &outchar, 1);
00109 }
00110 
00111 
00112 /* use this function to switch the host port currently being controlled */
00113 char select_host_port(portstream_fd portstream)
00114         {  current_host_port = portstream;
00115                 return(0);
00116         }
00117 
00118 
00119 
00120 /* reset_PTU() ==> <status> */
00121 char reset_ptu(void)
00122         {  unsigned char c;
00123 
00124                 SerialOut(UNIT_RESET);
00125                 while ( ((c = GetSerialChar(TRUE)) == PAN_LIMIT_HIT) ||
00126                                   (c == TILT_LIMIT_HIT) );
00127                 return(c);
00128         }
00129 
00130 
00131 
00132 /* an internal function that verifies that the PTU controller firmware
00133    supports this binary interface. TRUE when OK, otherwise error code.
00134    This function communicates in ASCII to ensure proper unit communication. 
00135    Added 10 sec timeout on read to allow fall-out from non-responsive PTU. */
00136 char firmware_version_OK(void)
00137 {   unsigned char *tmpStr;
00138     char c1, c2;
00139     int modelVersion, codeVersion, revision;
00140     unsigned char versionSTR[256];
00141     int charsRead=0;
00142     int status;
00143     unsigned char initString[] = "    v ";
00144 
00145         do_delay(500);
00146         if (FlushInputBuffer(current_host_port) != TRUE)
00147            printf ("\nERROR(firmware_version_OK): FlushInputBuffer failed\n");
00148         tmpStr = initString;
00149         if ( (status = SerialBytesOut(current_host_port, tmpStr, 6)) != TRUE )
00150            { printf ("\nERROR(firmware_version_OK): SerialBytesOut error %d\n", status);
00151              return(FALSE);
00152         }
00153         do_delay(500);
00154 
00155         switch ( ReadSerialLine(current_host_port, versionSTR, 10000, &charsRead) ) {
00156                 case TRUE:                                      
00157                                 break;
00158                 case TIMEOUT_CHAR_READ:         
00159                                 printf("\nERROR(firmware_version_OK): timeout on ReadSerialLine (%d read)\n", charsRead);
00160                                 return(TIMEOUT_CHAR_READ);
00161                 default:                                        
00162                                 printf("\nERROR(firmware_version_OK): ReadSerialLine error\n");
00163                                 return(FALSE);
00164         }
00165         /* parse to the beginning of the version ID (fix for ft mode on 7/28/99) */
00166         tmpStr = versionSTR;
00167         while ( tolower(*tmpStr) != '*' ) tmpStr++;
00168         while ( tolower(*tmpStr) != 'v' ) tmpStr++;
00169         tmpStr++;
00170         sscanf((char *) tmpStr, "%1d %c %2d %c %2d",
00171                                 &modelVersion, &c1, &codeVersion, &c2, &revision);
00172 
00173         if ( /* ensure the version numbers seem reasonable as version numbers, and
00174                     the version number is high enough */
00175                  ((modelVersion < 999)  && (modelVersion >= PTU_modelVersion)) ||
00176                  ((codeVersion  < 999)  && (codeVersion  >= PTU_codeVersion))  ||
00177                  ((revision     < 9999) && (revision     >= PTU_revision)) ) 
00178                   { printf("\n\nController firmware v%d.%d.%d is compatible\n\n",
00179                                           modelVersion, codeVersion, revision);
00180                          return(TRUE); /* the controller firmware is compatible */
00181                   }
00182         else { printf("\n\nPTU Controller firmware version v%d.%d.%d is NOT compatible:\n\tversion v%d.%d.%d and higher is required\n   charsRead='%s'\n",
00183                                           modelVersion, codeVersion, revision,
00184                                           PTU_modelVersion, PTU_codeVersion, PTU_revision,
00185                                           charsRead);
00186                          return(FALSE);
00187                   }
00188 
00189 }
00190 
00191 
00192 
00193 /* Flushes the PTU parser so that pending command parses are terminated,
00194         and the call blocks until the PTU is ready to accept the next command
00195         or it times out before the PTU responds that it is OK. */
00196 /* reset_PTU_parser(<timeout_in_msec>) ==> [PTU_OK|PTU_NOT_RESPONDING] */
00197 char reset_PTU_parser(long timeout_in_msec)
00198         { long elapsed_time = 250;
00199           char status;
00200 
00201           do_delay(500);                                   /* allows pending PTU commands to complete */
00202           FlushInputBuffer(current_host_port);             /* flushes the PTU return info */
00203           SerialOut(' '); SerialOut(' '); SerialOut(' ');  /* terminates any pending parses */
00204           do_delay(250);      /* allows the return of any PTU info from the termination */
00205 
00206           if ( (status = firmware_version_OK()) != TRUE )
00207              return(status);
00208 
00209           /* now make sure the PTU is responding to commands */
00210           for (;;)
00211                  { /* issue a command and ensure it looks legal */
00212                         SerialOut(PAN_HOLD_POWER_QUERY);
00213                         /* do_delay(250);  */
00214                         status = GetSerialChar(FALSE);
00215                         if ( (status >= PTU_REG_POWER) & (status <= PTU_OFF_POWER) )
00216                                 { /* things look OK, so flush and unblock */
00217                                   FlushInputBuffer(current_host_port); /* flushes the PTU return info */
00218                                   return(PTU_OK);
00219                                 }
00220                         else
00221                                 { /* there's a problem, so flush, delay, and retry */
00222                                   FlushInputBuffer(current_host_port); /* flushes the PTU return info */
00223                                   do_delay(500);
00224                                   elapsed_time += 750;
00225                                   if (elapsed_time > timeout_in_msec)
00226                                           return(PTU_NOT_RESPONDING);
00227                                 }}
00228         }
00229 
00230 
00231 /* set_desired([PAN|TILT],
00232                 [POSITION|SPEED|ACCELERATION|BASE|UPPER|LOWER],
00233                 [<position>|<speed>|<acceleration>],
00234                 [RELATIVE|ABSOLUTE]) ==> <status>
00235         set_desired([PAN|TILT],
00236                 [HOLD_POWER_LEVEL,MOVE_POWER_LEVEL],
00237                 <power mode>,
00238                 NULL) ==> <status>                              */
00239 char set_desired(char axis, char kinematic_property,
00240                      PTU_PARM_PTR *value, char movement_mode)
00241         { unsigned short int uvalue;
00242           long lvalue;
00243           char cvalue;
00244 
00245           switch (kinematic_property)   {
00246                         case POSITION:
00247                                         switch (axis)  {
00248                                                 case PAN:
00249                                                          switch (movement_mode) {
00250                                                                 case RELATIVE: SerialOut(PAN_SET_REL_POS);
00251                                                                                                         break;
00252                                                                 case ABSOLUTE: SerialOut(PAN_SET_ABS_POS);
00253                                                                                                         break;
00254                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00255                                                          }
00256                                                          break;
00257                                                 case TILT:
00258                                                          switch (movement_mode) {
00259                                                                 case RELATIVE: SerialOut(TILT_SET_REL_POS);
00260                                                                                                         break;
00261                                                                 case ABSOLUTE: SerialOut(TILT_SET_ABS_POS);
00262                                                                                                         break;
00263                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00264                                                          }
00265                                                          break;
00266                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);          }
00267                                         PutSignedShort(current_host_port, (signed short *) value);
00268                                         break;
00269                         case SPEED:
00270                                         switch (axis)  {
00271                                                 case PAN:
00272                                                          switch (movement_mode) {
00273                                                                 case RELATIVE: SerialOut(PAN_SET_REL_SPEED);
00274                                                                                            PutSignedShort(current_host_port, (signed short *) value);
00275                                                                                            break;
00276                                                                 case ABSOLUTE: SerialOut(PAN_SET_ABS_SPEED);
00277                                                                                            if (speed_control_mode == PTU_INDEPENDENT_SPEED_CONTROL_MODE)
00278                                                                                                   { uvalue = *((unsigned short *) value);
00279                                                                                                     PutUnsignedShort(current_host_port, &uvalue);               }
00280                                                                                            else
00281                                                                                                   { PutSignedShort(current_host_port, (signed short *) value);          }
00282                                                                                            break;
00283                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00284                                                          }
00285                                                          break;
00286                                                 case TILT:
00287                                                          switch (movement_mode) {
00288                                                                 case RELATIVE: SerialOut(TILT_SET_REL_SPEED);
00289                                                                                            PutSignedShort(current_host_port, (signed short *) value);
00290                                                                                            break;
00291                                                                 case ABSOLUTE: SerialOut(TILT_SET_ABS_SPEED);
00292                                                                                            if (speed_control_mode == PTU_INDEPENDENT_SPEED_CONTROL_MODE)
00293                                                                                                   { uvalue = *((unsigned short *) value);
00294                                                                                                         PutUnsignedShort(current_host_port, &uvalue);           }
00295                                                                                            else
00296                                                                                                   { PutSignedShort(current_host_port, (signed short *) value);          }
00297                                                                                            break;
00298                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00299                                                          }
00300                                                          break;
00301                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);          }
00302                                                 break;
00303                         case ACCELERATION:
00304                                         lvalue = *((long *)value);
00305                                         switch (axis)  {
00306                                                 case PAN:
00307                                                          switch (movement_mode) {
00308                                                                 case RELATIVE: lvalue += get_current(PAN,ACCELERATION);
00309                                                                                                         SerialOut(PAN_SET_ACCEL);
00310                                                                                                         break;
00311                                                                 case ABSOLUTE: SerialOut(PAN_SET_ACCEL);
00312                                                                                                         break;
00313                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00314                                                          }
00315                                                          break;
00316                                                 case TILT:
00317                                                          switch (movement_mode) {
00318                                                                 case RELATIVE: lvalue += get_current(TILT,ACCELERATION);
00319                                                                                                         SerialOut(TILT_SET_ACCEL);
00320                                                                                                         break;
00321                                                                 case ABSOLUTE: SerialOut(TILT_SET_ACCEL);
00322                                                                                                         break;
00323                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00324                                                          }
00325                                                          break;
00326                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);          }
00327                                         PutSignedLong(current_host_port, &lvalue);
00328                                   break;
00329                         case BASE:
00330                                         switch (axis)  {
00331                                                 case PAN:
00332                                                          switch (movement_mode) {
00333                                                                 case RELATIVE:
00334                                                                 case ABSOLUTE: SerialOut(PAN_SET_BASE_SPEED);
00335                                                                                                         break;
00336                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00337                                                          }
00338                                                          break;
00339                                                 case TILT:
00340                                                          switch (movement_mode) {
00341                                                                 case RELATIVE:
00342                                                                 case ABSOLUTE: SerialOut(TILT_SET_BASE_SPEED);
00343                                                                                                         break;
00344                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00345                                                          }
00346                                                          break;
00347                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);          }
00348                                         uvalue = *((unsigned short int*) value);
00349                                         PutUnsignedShort(current_host_port, &uvalue);
00350                                   break;
00351                         case UPPER_SPEED_LIMIT:
00352                                         switch (axis)  {
00353                                                 case PAN:
00354                                                          switch (movement_mode) {
00355                                                                 case RELATIVE:
00356                                                                 case ABSOLUTE: SerialOut(PAN_SET_UPPER_SPEED_LIMIT);
00357                                                                                            break;
00358                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00359                                                          }
00360                                                          break;
00361                                                 case TILT:
00362                                                          switch (movement_mode) {
00363                                                                 case RELATIVE:
00364                                                                 case ABSOLUTE: SerialOut(TILT_SET_UPPER_SPEED_LIMIT);
00365                                                                                                         break;
00366                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00367                                                          }
00368                                                          break;
00369                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);          }
00370                                         uvalue = *((unsigned short int*) value);
00371                                         PutUnsignedShort(current_host_port, &uvalue);
00372                                   break;
00373                         case LOWER_SPEED_LIMIT:
00374                                         switch (axis)  {
00375                                                 case PAN:
00376                                                          switch (movement_mode) {
00377                                                                 case RELATIVE:
00378                                                                 case ABSOLUTE: SerialOut(PAN_SET_LOWER_SPEED_LIMIT);
00379                                                                                                         break;
00380                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00381                                                          }
00382                                                          break;
00383                                                 case TILT:
00384                                                          switch (movement_mode) {
00385                                                                 case RELATIVE:
00386                                                                 case ABSOLUTE: SerialOut(TILT_SET_LOWER_SPEED_LIMIT);
00387                                                                                                         break;
00388                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00389                                                          }
00390                                                          break;
00391                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);          }
00392                                         uvalue = *((unsigned short int*) value);
00393                                         PutUnsignedShort(current_host_port, &uvalue);
00394                                   break;
00395                         case HOLD_POWER_LEVEL:
00396                                         switch (axis)  {
00397                                                 case PAN:
00398                                                          switch (movement_mode) {
00399                                                                 case RELATIVE:
00400                                                                 case ABSOLUTE: SerialOut(PAN_SET_HOLD_POWER);
00401                                                                                                         break;
00402                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00403                                                          }
00404                                                          break;
00405                                                 case TILT:
00406                                                          switch (movement_mode) {
00407                                                                 case RELATIVE:
00408                                                                 case ABSOLUTE: SerialOut(TILT_SET_HOLD_POWER);
00409                                                                                                         break;
00410                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00411                                                          }
00412                                                          break;
00413                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);          }
00414                                         cvalue = *((unsigned char*) value);
00415                                         SerialOut((unsigned char) cvalue);
00416                                   break;
00417                         case MOVE_POWER_LEVEL:
00418                                         switch (axis)  {
00419                                                 case PAN:
00420                                                          switch (movement_mode) {
00421                                                                 case RELATIVE:
00422                                                                 case ABSOLUTE: SerialOut(PAN_SET_MOVE_POWER);
00423                                                                                                         break;
00424                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00425                                                          }
00426                                                          break;
00427                                                 case TILT:
00428                                                          switch (movement_mode) {
00429                                                                 case RELATIVE:
00430                                                                 case ABSOLUTE: SerialOut(TILT_SET_MOVE_POWER);
00431                                                                                                         break;
00432                                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00433                                                          }
00434                                                          break;
00435                                                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);          }
00436                                         cvalue = *((unsigned char*) value);
00437                                         SerialOut((unsigned char) cvalue);
00438                                   break;
00439                         default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00440                         }
00441 
00442 
00443         return(GetSerialChar(TRUE));    /* return the command execution status */
00444 
00445         }
00446 
00447 
00448 /* await_completion() ==> <status> */
00449 char await_completion(void)
00450         { SerialOut(AWAIT_COMMAND_COMPLETION);
00451           return( GetSerialChar(TRUE) );
00452           }
00453 
00454 
00455 /* get_current([PAN|TILT],
00456                 [POSITION|SPEED|ACCELERATION|BASE|
00457                  UPPER_SPEED_LIMIT|LOWER_SPEED_LIMIT|
00458                  MINIMUM_POSITION|MAXIMUM_POSITION|
00459                  RESOLUTION|
00460                  HOLD_POWER_LEVEL|MOVE_POWER_LEVEL|]) ==> <value> */
00461 long get_current(char axis, char kinematic_property)
00462         { unsigned short int uvalue;
00463           signed short int value;
00464      long long_value;
00465 
00466           switch (kinematic_property)   {
00467                         case POSITION:
00468                                         switch (axis)  {
00469                                                 case PAN:       SerialOut(PAN_CURRENT_POS_QUERY);
00470                                                                         goto get_and_return_signed_short_int;
00471                                                 case TILT:  SerialOut(TILT_CURRENT_POS_QUERY);
00472                                                                         goto get_and_return_signed_short_int;
00473                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00474                                                 }
00475                         case SPEED:
00476                                         switch (axis)  {
00477                                                 case PAN:   SerialOut(PAN_CURRENT_SPEED_QUERY);
00478                                                                         if (speed_control_mode == PTU_INDEPENDENT_SPEED_CONTROL_MODE)
00479                                                                            goto get_and_return_unsigned_short_int;
00480                                                                         else
00481                                                                            goto get_and_return_signed_short_int;
00482                                                 case TILT:  SerialOut(TILT_CURRENT_SPEED_QUERY);
00483                                                                         if (speed_control_mode == PTU_INDEPENDENT_SPEED_CONTROL_MODE)
00484                                                                            goto get_and_return_unsigned_short_int;
00485                                                                         else
00486                                                                            goto get_and_return_signed_short_int;
00487                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00488                                                 }
00489                         case ACCELERATION:
00490                                         switch (axis)  {
00491                                                 case PAN:       SerialOut(PAN_ACCEL_QUERY);
00492                                                                         goto get_and_return_long;
00493                                                 case TILT:  SerialOut(TILT_ACCEL_QUERY);
00494                                                                         goto get_and_return_long;
00495                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00496                                                 }
00497                         case BASE:
00498                                         switch (axis)  {
00499                                                 case PAN:       SerialOut(PAN_BASE_SPEED_QUERY);
00500                                                                         goto get_and_return_unsigned_short_int;
00501                                                 case TILT:  SerialOut(TILT_BASE_SPEED_QUERY);
00502                                                                         goto get_and_return_unsigned_short_int;
00503                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00504                                                 }
00505                         case UPPER_SPEED_LIMIT:
00506                                         switch (axis)  {
00507                                                 case PAN:       SerialOut(PAN_UPPER_SPEED_LIMIT_QUERY);
00508                                                                         goto get_and_return_unsigned_short_int;
00509                                                 case TILT:      SerialOut(TILT_UPPER_SPEED_LIMIT_QUERY);
00510                                                                         goto get_and_return_unsigned_short_int;
00511                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00512                                                 }
00513                         case LOWER_SPEED_LIMIT:
00514                                         switch (axis)  {
00515                                                 case PAN:       SerialOut(PAN_LOWER_SPEED_LIMIT_QUERY);
00516                                                                         goto get_and_return_unsigned_short_int;
00517                                                 case TILT:  SerialOut(TILT_LOWER_SPEED_LIMIT_QUERY);
00518                                                                         goto get_and_return_unsigned_short_int;
00519                                                 default:    return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00520                                                 }
00521                         case MINIMUM_POSITION:
00522                                         switch (axis)  {
00523                                                 case PAN:       SerialOut(PAN_MIN_POSITION_QUERY);
00524                                                                         goto get_and_return_signed_short_int;
00525                                                 case TILT:  SerialOut(TILT_MIN_POSITION_QUERY);
00526                                                                         goto get_and_return_signed_short_int;
00527                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00528                                                 }
00529                         case MAXIMUM_POSITION:
00530                                         switch (axis)  {
00531                                                 case PAN:       SerialOut(PAN_MAX_POSITION_QUERY);
00532                                                                         goto get_and_return_signed_short_int;
00533                                                 case TILT:  SerialOut(TILT_MAX_POSITION_QUERY);
00534                                                                         goto get_and_return_signed_short_int;
00535                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00536                                                 }
00537                         case RESOLUTION:
00538                                         switch (axis)  {
00539                                                 case PAN:       SerialOut(PAN_RESOLUTION_QUERY);
00540                                                                         goto get_and_return_long;
00541                                                 case TILT:  SerialOut(TILT_RESOLUTION_QUERY);
00542                                                                         goto get_and_return_long;
00543                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00544                                                 }
00545                         case HOLD_POWER_LEVEL:
00546                                         switch (axis)  {
00547                                                 case PAN:       SerialOut(PAN_HOLD_POWER_QUERY);
00548                                                                         goto get_and_return_char;
00549                                                 case TILT:  SerialOut(TILT_HOLD_POWER_QUERY);
00550                                                                         goto get_and_return_char;
00551                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00552                                                 }
00553                         case MOVE_POWER_LEVEL:
00554                                         switch (axis)  {
00555                                                 case PAN:       SerialOut(PAN_MOVE_POWER_QUERY);
00556                                                                         goto get_and_return_char;
00557                                                 case TILT:  SerialOut(TILT_MOVE_POWER_QUERY);
00558                                                                         goto get_and_return_char;
00559                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00560                                                 }
00561                         default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00562                 }
00563 
00564         get_and_return_unsigned_short_int:
00565                 err = GetUnsignedShort(current_host_port, &uvalue, -1);
00566                 long_value = uvalue;
00567                 return(long_value);
00568 
00569         get_and_return_signed_short_int:
00570                 err = GetSignedShort(current_host_port, &value, -1);
00571                 long_value = value;
00572                 return(long_value);
00573 
00574         get_and_return_long:
00575                 err = GetSignedLong(current_host_port, &long_value, -1);
00576                 return(long_value);
00577 
00578         get_and_return_char:
00579                 long_value = (long) GetSerialChar(TRUE);
00580                 return(long_value);
00581                 
00582 }
00583 
00584 
00585 
00586 /* get_desired([PAN|TILT],
00587                 [POSITION|SPEED|ACCELERATION|BASE|
00588                  UPPER_SPEED_LIMIT|LOWER_SPEED_LIMIT|
00589                  MINIMUM_POSITION|MAXIMUM_POSITION|
00590                  RESOLUTION|
00591                  HOLD_POWER_LEVEL|MOVE_POWER_LEVEL]) ==> <ptr to value> */
00592 long get_desired(char axis, char kinematic_property)
00593         { unsigned short int uvalue;
00594           signed short int value;
00595       long long_value;
00596 
00597           switch (kinematic_property)   {
00598                         case POSITION:
00599                                         switch (axis)  {
00600                                                 case PAN:   SerialOut(PAN_DESIRED_POS_QUERY);
00601                                                                         goto get_and_return_signed_short_int;
00602                                                 case TILT:  SerialOut(TILT_DESIRED_POS_QUERY);
00603                                                                         goto get_and_return_signed_short_int;
00604                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00605                                                 }
00606                         case SPEED:
00607                                         switch (axis)  {
00608                                                 case PAN:   SerialOut(PAN_DESIRED_SPEED_QUERY);
00609                                                                         if (speed_control_mode == PTU_INDEPENDENT_SPEED_CONTROL_MODE)
00610                                                                            goto get_and_return_unsigned_short_int;
00611                                                                         else
00612                                                                            goto get_and_return_signed_short_int;
00613                                                 case TILT:  SerialOut(TILT_DESIRED_SPEED_QUERY);
00614                                                                         if (speed_control_mode == PTU_INDEPENDENT_SPEED_CONTROL_MODE)
00615                                                                            goto get_and_return_unsigned_short_int;
00616                                                                         else
00617                                                                            goto get_and_return_signed_short_int;
00618                                                 default:    return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00619                                                 }
00620                         case ACCELERATION:
00621                                         switch (axis)  {
00622                                                 case PAN:   SerialOut(PAN_ACCEL_QUERY);
00623                                                                         goto get_and_return_long;
00624                                                 case TILT:  SerialOut(TILT_ACCEL_QUERY);
00625                                                                         goto get_and_return_long;
00626                                                 default:    return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00627                                                 }
00628                         case BASE:
00629                                         switch (axis)  {
00630                                                 case PAN:       SerialOut(PAN_BASE_SPEED_QUERY);
00631                                                                         goto get_and_return_unsigned_short_int;
00632                                                 case TILT:  SerialOut(TILT_BASE_SPEED_QUERY);
00633                                                                         goto get_and_return_unsigned_short_int;
00634                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00635                                                 }
00636                         case UPPER_SPEED_LIMIT:
00637                                         switch (axis)  {
00638                                                 case PAN:       SerialOut(PAN_UPPER_SPEED_LIMIT_QUERY);
00639                                                                         goto get_and_return_unsigned_short_int;
00640                                                 case TILT:      SerialOut(TILT_UPPER_SPEED_LIMIT_QUERY);
00641                                                                         goto get_and_return_unsigned_short_int;
00642                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00643                                                 }
00644                         case LOWER_SPEED_LIMIT:
00645                                         switch (axis)  {
00646                                                 case PAN:       SerialOut(PAN_LOWER_SPEED_LIMIT_QUERY);
00647                                                                         goto get_and_return_unsigned_short_int;
00648                                                 case TILT:  SerialOut(TILT_LOWER_SPEED_LIMIT_QUERY);
00649                                                                         goto get_and_return_unsigned_short_int;
00650                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00651                                                 }
00652                         case MINIMUM_POSITION:
00653                                         switch (axis)  {
00654                                                 case PAN:       SerialOut(PAN_MIN_POSITION_QUERY);
00655                                                                         goto get_and_return_signed_short_int;
00656                                                 case TILT:  SerialOut(TILT_MIN_POSITION_QUERY);
00657                                                                         goto get_and_return_signed_short_int;
00658                                                 default: break;
00659                                                 }
00660                         case MAXIMUM_POSITION:
00661                                         switch (axis)  {
00662                                                 case PAN:       SerialOut(PAN_MAX_POSITION_QUERY);
00663                                                                         goto get_and_return_signed_short_int;
00664                                                 case TILT:  SerialOut(TILT_MAX_POSITION_QUERY);
00665                                                                         goto get_and_return_signed_short_int;
00666                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00667                                                 }
00668                         case RESOLUTION:
00669                                         switch (axis)  {
00670                                                 case PAN:   SerialOut(PAN_RESOLUTION_QUERY);
00671                                                                         goto get_and_return_long;
00672                                                 case TILT:  SerialOut(TILT_RESOLUTION_QUERY);
00673                                                                         goto get_and_return_long;
00674                                                 default:    return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00675                                                 }
00676                         case HOLD_POWER_LEVEL:
00677                                         switch (axis)  {
00678                                                 case PAN:       SerialOut(PAN_HOLD_POWER_QUERY);
00679                                                                         goto get_and_return_char;
00680                                                 case TILT:  SerialOut(TILT_HOLD_POWER_QUERY);
00681                                                                         goto get_and_return_char;
00682                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00683                                                 }
00684                         case MOVE_POWER_LEVEL:
00685                                         switch (axis)  {
00686                                                 case PAN:       SerialOut(PAN_MOVE_POWER_QUERY);
00687                                                                         goto get_and_return_char;
00688                                                 case TILT:  SerialOut(TILT_MOVE_POWER_QUERY);
00689                                                                         goto get_and_return_char;
00690                                                 default:        return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00691                                                 }
00692                         default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00693 
00694                 }
00695 
00696         get_and_return_unsigned_short_int:
00697                 err = GetUnsignedShort(current_host_port, &uvalue,-1);
00698                 long_value = uvalue;
00699                 return(long_value);
00700 
00701         get_and_return_signed_short_int:
00702                 err = GetSignedShort(current_host_port, &value,-1);
00703                 long_value = value;
00704                 return(long_value);
00705 
00706         get_and_return_long:
00707                 err = GetSignedLong(current_host_port, &long_value,-1);
00708                 return(long_value);
00709 
00710         get_and_return_char:
00711                 long_value = (long) GetSerialChar(TRUE);
00712                 return(long_value);
00713 
00714 }
00715 
00716 
00717 /* set_mode(COMMAND_EXECUTION_MODE,
00718                 [EXECUTE_IMMEDIATELY|EXECUTE_UPON_IMMEDIATE_OR_AWAIT]) ==> <status>
00719    set_mode(ASCII_VERBOSE_MODE, [VERBOSE|TERSE|QUERY_MODE]) ==> <status>
00720    set_mode(ASCII_ECHO_MODE, [ON_MODE|OFF_MODE|QUERY_MODE] ==> <status>
00721    set_mode(POSITION_LIMITS_MODE, [ON_MODE|OFF_MODE|QUERY_MODE] ==> <status>
00722    set_mode(DEFAULTS,[SAVE_CURRENT_SETTINGS|RESTORE_SAVED_SETTINGS|RESTORE_FACTORY_SETTINGS]) ==> <status>
00723    *** below is only supported by PTU firmware versions 1.9.7 and higher.                        ***
00724    *** This call must be made before pure velocity speed control mode made be used by CPI calls. ***
00725    set_mode(SPEED_CONTROL_MODE, [PTU_INDEPENDENT_SPEED_CONTROL_MODE |
00726                                                                  PTU_PURE_VELOCITY_SPEED_CONTROL_MODE | QUERY_MODE] ==> <status>
00727 */ 
00728 char set_mode(char mode_type, char mode_parameter)
00729         { switch (mode_type) {
00730                 case DEFAULTS:
00731                                 {switch (mode_parameter) {
00732                                         case SAVE_CURRENT_SETTINGS:
00733                                                                 SerialOut(SAVE_DEFAULTS);
00734                                                                 goto return_status;
00735                                         case RESTORE_SAVED_SETTINGS:
00736                                                                 SerialOut(RESTORE_SAVED_DEFAULTS);
00737                                                                 goto return_status;
00738                                         case RESTORE_FACTORY_SETTINGS:
00739                                                                 SerialOut(RESTORE_FACTORY_DEFAULTS);
00740                                                                 goto return_status;
00741                                         default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00742                                         }}
00743                 case ASCII_ECHO_MODE:
00744                                 {switch (mode_parameter) {
00745                                         case ON_MODE:
00746                                                                 SerialOut(ENABLE_ECHO);
00747                                                                 goto return_status;
00748                                         case OFF_MODE:
00749                                                                 SerialOut(DISABLE_ECHO);
00750                                                                 goto return_status;
00751                                         case QUERY_MODE:
00752                                                                 SerialOut(ECHO_QUERY);
00753                                                                 goto return_status;
00754                                         default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00755                                         }}
00756                 case COMMAND_EXECUTION_MODE:
00757                                 switch (mode_parameter) {
00758                                         case EXECUTE_IMMEDIATELY:
00759                                                                 SerialOut(SET_IMMEDIATE_COMMAND_MODE);
00760                                                                 break;
00761                                         case EXECUTE_UPON_IMMEDIATE_OR_AWAIT:
00762                                                                 SerialOut(SET_SLAVED_COMMAND_MODE);
00763                                                                 break;
00764                                         default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00765                                         }
00766                                 break;
00767                 case ASCII_VERBOSE_MODE:
00768                                 {switch (mode_parameter) {
00769                                         case VERBOSE:
00770                                                                 SerialOut(SET_VERBOSE_ASCII_ON);
00771                                                                 break;
00772                                         case TERSE:
00773                                                                 SerialOut(SET_VERBOSE_ASCII_OFF);
00774                                                                 break;
00775                                         case QUERY_MODE:
00776                                                                 SerialOut(VERBOSE_QUERY);
00777                                                                 break;
00778                                         default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00779                                         }}
00780                                 break;
00781                 case POSITION_LIMITS_MODE:
00782                                 {switch (mode_parameter) {
00783                                         case ON_MODE:
00784                                                                 SerialOut(ENABLE_POSITION_LIMITS);
00785                                                                 break;
00786                                         case OFF_MODE:
00787                                                                 SerialOut(DISABLE_POSITION_LIMITS);
00788                                                                 break;
00789                                         case QUERY_MODE:
00790                                                                 SerialOut(POSITION_LIMITS_QUERY);
00791                                                                 break;
00792                                         default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00793                                         }}
00794                                 break;
00795                 case SPEED_CONTROL_MODE:
00796                                 {switch (mode_parameter) {
00797                                         case PTU_INDEPENDENT_SPEED_CONTROL_MODE:
00798                                                                 speed_control_mode = PTU_INDEPENDENT_SPEED_CONTROL_MODE;
00799                                                         SerialOut(SET_INDEPENDENT_CONTROL_MODE);
00800                                                                 break;
00801                                         case PTU_PURE_VELOCITY_SPEED_CONTROL_MODE:
00802                                                                 speed_control_mode = PTU_PURE_VELOCITY_SPEED_CONTROL_MODE;
00803                                                         SerialOut(SET_PURE_VELOCITY_CONTROL_MODE);
00804                                                                 break;
00805                                         case QUERY_MODE:
00806                                                                 SerialOut(QUERY_SPEED_CONTROL_MODE);
00807                                                                 break;
00808                                         default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00809                                         }}
00810                                 break;          
00811                 default: return(PTU_ILLEGAL_COMMAND_ARGUMENT);
00812         }
00813   return_status:
00814         return( GetSerialChar(TRUE) );  /* return <status> */
00815 }
00816 
00817 
00818 /* halt([ALL|PAN|TILT]) ==> <status>    */
00819 char halt(char halt_type)
00820         { switch(halt_type) {
00821                 case PAN:   SerialOut(HALT_PAN);
00822                                                 break;
00823                 case TILT:  SerialOut(HALT_TILT);
00824                                                 break;
00825                 default:    SerialOut(HALT);
00826                                                 break;
00827                 }
00828           return( GetSerialChar(TRUE) );
00829         }
00830 
00831 
00832 /* firmware_version() ==> <version ID string> */
00833 char* firmware_version(void)
00834 {  static unsigned char version_ID_string[256];
00835         int charsRead;
00836 
00837         SerialOut(FIRMWARE_VERSION_QUERY);
00838         do_delay(1000);
00839         ReadSerialLine(current_host_port, version_ID_string,0,&charsRead);
00840         return((char *) version_ID_string);
00841 }
00842 
00843 
00844 
00845 /* modified 5/12/99  */
00846 char select_unit(UID_fd unit_ID)
00847         { char UID_select[10];
00848 
00849           sprintf(UID_select, "  _%d ", unit_ID);
00850           SerialBytesOut(current_host_port, (unsigned char*) UID_select, strlen(UID_select));
00851                 
00852           /* the below only works for PTU firmware v1.9.11r3 and above */
00853           /* SerialOut(SELECT_UNIT_ID); */
00854           /* PutUnsignedShort(current_host_port, &unit_ID); */
00855 
00856           return TRUE;
00857         }
00858 
00859 
00860 
00861 /*  modified 10/19/98  */
00862 char set_unit_id(UID_fd unit_ID)
00863         {   SerialOut(SET_UNIT_ID);
00864         PutUnsignedShort(current_host_port, &unit_ID); 
00865         return GetSerialChar(TRUE);
00866         }
00867 
00868 

Generado el Tue Apr 24 06:55:48 2001 para Dllcontrol por doxygen1.2.6 escrito por Dimitri van Heesch, © 1997-2001