home *** CD-ROM | disk | FTP | other *** search
/ Virtual Reality Zone / VRZONE.ISO / mac / PC / PCGLOVE / GLOVE / OBJGLV.ZIP / INCLUDE / HARDWARE.HPP < prev    next >
C/C++ Source or Header  |  1993-04-26  |  6KB  |  223 lines
  1. //
  2. // Hardware.hpp:
  3. //    Interface Definition of classes parallelPort, machineTimer,
  4. //    and gloveDriver.  Part of Object Glove library.
  5. //
  6. // Copyright 1992, 1993   Mark Thomas Pflaging
  7. //
  8. // Date:    5/15/92 - 6/4/92 (Release 1)
  9. //        8/9/92 - 9/21/92 (Release 2)
  10. //                11/20/92 (Release 2.1)
  11. //                   3/22/93 (Release 3.0)     
  12. //
  13. #ifndef __HARDWARE_HPP
  14. #define __HARDWARE_HPP
  15.  
  16. #include <dos.h>
  17.  
  18. #include "GloveDat.hpp"
  19. #include "Fingers.hpp"
  20. #include "AbsGest.hpp"
  21.  
  22. #ifndef _Windows
  23. #include "t_types.h"
  24. #include "htimer.h"
  25. #endif
  26.  
  27. #include "isr.hpp"
  28. #include "ini.hpp"
  29.  
  30. // bits for i/o ports
  31. class subPort {
  32.  
  33. protected:
  34.     unsigned char GDATA;    // PG data in
  35.     unsigned char GSHIFT;    // Number of Bits to shift
  36.     unsigned char GLATCH;    // PG latch out
  37.     unsigned char GCLOCK;    // PG clock out
  38.     unsigned char GCLOLAT;    // clock + latch
  39.  
  40. public:
  41.     subPort(unsigned char gdata,
  42.         unsigned char glatch,
  43.         unsigned char gclock);
  44.     subPort() {}
  45. };
  46.  
  47. class parallelPort : subPort {
  48. public:
  49.     enum tPort {
  50.         LPT1a = (int)'1',
  51.         LPT1b,
  52.         LPT2a,
  53.         LPT2b,
  54.         LPT3a,
  55.         LPT3b
  56.     };
  57.     enum searchType { RR, RL, LL };
  58.  
  59. private:
  60.     static char * title;
  61.     static subPort primary;
  62.     static subPort secondary;
  63.     static searchType RightRight;
  64.     int     InPort, OutPort;
  65.     tPort which;
  66.     Boolean polarity;
  67.     static int userOutPort;
  68.     void set_glove_inPort( int ip ) { InPort = ip; }
  69.     void set_glove_outPort( int op ) { OutPort = op; }
  70.     void set_user_port(InitFile & ini, int instance);
  71.  
  72. public:
  73.     parallelPort(InitFile & ini, int instance);
  74.     parallelPort(InitFile & ini, tPort p, int instance);
  75.     setPort(tPort p);
  76.     Boolean operator==(parallelPort & arg) {
  77.         return ((arg.which == which) ? True : False);
  78.     }
  79.     parallelPort & operator++() {
  80.         which = (tPort)(which + (((RightRight == RR) || (RightRight == LL)) ? 1 : 2));
  81.         if (which > LPT3b) {
  82.             if (polarity) which = LPT1a;
  83.             else {
  84.                 if (RightRight == RL) which = LPT1b;
  85.                 else which = LPT1a;
  86.             }
  87.         }
  88.         setPort((tPort)(which));
  89.         return *this;
  90.     }
  91.     // In the following function, the return value indicates left-
  92.     // or right-handedness.  True = right hand, False = left hand.
  93.     // All gloves will return True if SearchingAlgorithm=Right-Right
  94.     // in the .INI file.
  95.     Boolean getPolarity() { return polarity; } 
  96.  
  97.  
  98. protected:
  99.     unsigned char BITREAD() { return ( ( inportb( InPort ) & GDATA ) >> GSHIFT ); }
  100.     void C0L0() { outportb( OutPort, 0 ); }        // clock 0 latch 0.
  101.     void C0L1() { outportb( OutPort, GLATCH ); }   // clock 0 latch 1.
  102.     void C1L0() { outportb( OutPort, GCLOCK ); }   // clock 1 latch 0.
  103.     void C1L1() { outportb( OutPort, GCLOLAT ); }  // clock 1 latch 1.
  104. };
  105.  
  106. class machineTimer {
  107. #ifndef _Windows
  108.     HTimer * ptimer;
  109.     int count_once();
  110.     int get_count();
  111. #endif
  112.     // N and D will be calibrated.
  113.     unsigned long int Num;
  114.     unsigned long int Den;
  115.     unsigned long int val;
  116.     int test_value;
  117.  
  118.     // The following *function can be assigned to a
  119.     // function which will be executed in place of the
  120.     // instantiated delay loop.  Function execution time
  121.     // should be approximately the same as the instantiated
  122.     // delay.   -DPRC
  123.     // (Frankly, I would be surprised if you actually
  124.     // found a use for this. -mtp)
  125.     void (*timing_func) (void);
  126.  
  127. public:
  128.     machineTimer(unsigned int val, unsigned long N, unsigned long D)
  129.         : Num(N), Den (D), val((unsigned long)val) { }
  130.     // calibrates N and D
  131.     machineTimer(unsigned int val, void (*func) (void),
  132.         char * ascN = NULL, char * ascD = NULL);
  133.  
  134. #ifdef _Windows
  135.     int isValid() { return test_value; }
  136. #endif
  137.     // The infamous delay loop!!
  138.     void fdelay();
  139.     void fdelay(int newdelay);
  140.     // Now appearing at area theaters in static form!
  141.     static void fdelay(unsigned long N, unsigned long D,
  142.         unsigned long val);
  143.  
  144.     void multipliedDelay(int multiplier);
  145.     void test();
  146.     unsigned long getNum() { return Num; }
  147.     unsigned long getDen() { return Den; }
  148.     unsigned long getVal() { return val; }
  149.     int getTestValue() { return test_value; }
  150. };
  151.  
  152. // Set the maximum number of gloves!
  153. #define MAXGLOVES    6
  154.  
  155. class gloveDriver : parallelPort, segaISR, public GloveData {
  156.     // delay values for sending and sampling data.
  157.     static machineTimer * D2BYTES, * D2BITS, * D2SLOW;
  158.     static gloveDriver * forISR[MAXGLOVES];    // see hardware.cpp
  159.     static int currentGlove;
  160.     // # of interrupts to ignore glove so it
  161.     // will recover from mode setup
  162.     int glove_ignore;
  163.     // number of times glove has been not ready
  164.     int unready;
  165.     // number of samples "missed" by the client program.
  166.     unsigned nmissed;
  167.     // Number of MILLISECONDS between samples.
  168.     static int glove_tc;
  169.     // Number of milliseconds to go until next sample.
  170.     static int glove_pause;
  171.     static char * title;
  172.  
  173.     unsigned char get_glove_byte();    // read byte from glove
  174.     Boolean waitUntilReady();
  175.     static void gloveISR();
  176.     void intervalUpdate();
  177.     Boolean polledUpdate();
  178.     AbsGestureSystem * gestures;
  179.     void calibrate(InitFile & ini);
  180.     void setNextPort();
  181.     static void next_glove();
  182.  
  183. public:
  184.     typedef enum { EverythingOK, PolledModeWorking, DriverCoughing,
  185.         PolledModeCoughing, TooManyInstances, UserHitKey,
  186.         WindowsParametersMissing
  187.     } statusType;
  188.     gloveDriver(InitFile & ini, AbsGestureSystem * gs = NULL,
  189.         void (*sega_switcher)(int) = NULL, Boolean (*quit_func)());
  190.     virtual ~gloveDriver() {
  191.         if (isRunning()) terminate();
  192.         if (getInstantiations() == 1) {
  193.             delete D2BYTES;
  194.             delete D2BITS;
  195.             delete D2SLOW;
  196.         }
  197.         C0L0();
  198.     }
  199.     void Start(Boolean IntervalOrPolled = True);
  200.     virtual int updateGloveData();        // fill up the structure
  201.     void slowDelay(int i) { D2SLOW->multipliedDelay(i); }
  202.  
  203.     Boolean yield();
  204.     void waitForSample();
  205.     void test();
  206.     statusType driverStatus();
  207.     static gloveDriver & indexedDriver(int i) {
  208.         return *(forISR[i]);
  209.     }
  210.     static char * getTitle() { return title; }
  211.     parallelPort::getPolarity;
  212.     int whichGlove() { return getInstance(); }
  213.     void checkGestures() { if (gestures) gestures->check(); }
  214.     static size_t timeBetweenSamples() { return (getInstantiations() * glove_tc); }
  215.  
  216. protected:
  217.     Boolean is_glove_ready();    // Delay repeat calls by 2-4 ms
  218.  
  219.     void set_glove_hiResMode();    // puts glove in hires mode
  220. };
  221.  
  222. #endif
  223.