Return to whctm1.c CVS log

Up to [Witchaven I] / src

Annotation of src/whctm1.c, revision 1.1

1.1     ! root        1: /***************************************************************************
        !             2:  *   CTM.C  - CyberMAXX support routines                                   *
        !             3:  *            uses: SERIAL1.LIB functions                                  *
        !             4:  *   Written by: Les Bird                                                  *
        !             5:  ***************************************************************************/
        !             6: 
        !             7: #include "icorp.h"
        !             8: #include <time.h>
        !             9: #include "3d.h"
        !            10: 
        !            11: struct serialData sd;
        !            12: 
        !            13: //int  cyberenabled,
        !            14: int  iglassenabled;
        !            15: 
        !            16: void
        !            17: ctm_deinit(void)
        !            18: {
        !            19:      if (cyberenabled) {
        !            20:           deInitSerial(&sd);
        !            21:           cyberenabled=0;
        !            22:      }
        !            23: }
        !            24: 
        !            25: int
        !            26: ctm_init(int port)
        !            27: {
        !            28:      long cybcode=0,delayclock;
        !            29: 
        !            30:      if (initSerial(&sd,port,USE_16550,1024,1024) == SER_OK) {
        !            31:           cyberenabled=1;
        !            32:           setBPS(&sd,9600);
        !            33:           writeSer(&sd,'X');
        !            34:           delayclock=totalclock+CLKIPS;
        !            35:           while (totalclock < delayclock && cybcode < 3) {
        !            36:                if (rxBuffEmpty(&sd)) {
        !            37:                     continue;
        !            38:                }
        !            39:                switch (cybcode) {
        !            40:                case 0:
        !            41:                     if (readSer(&sd) == 'C') {
        !            42:                          cybcode++;
        !            43:                     }
        !            44:                     break;
        !            45:                case 1:
        !            46:                     if (readSer(&sd) == 'T') {
        !            47:                          cybcode++;
        !            48:                     }
        !            49:                     break;
        !            50:                case 2:
        !            51:                     if (readSer(&sd) == 'M') {
        !            52:                          cybcode++;
        !            53:                     }
        !            54:                     break;
        !            55:                }
        !            56:           }
        !            57:           if (cybcode != 3) {
        !            58:                ctm_deinit();
        !            59:                return(0);
        !            60:           }
        !            61:           writeSer(&sd,'C');       // CyberMAXX absolute coordinate mode
        !            62:           writeSer(&sd,'F');       // CyberMAXX binary transfer mode
        !            63:           writeSer(&sd,'M');       // CyberMAXX checksum byte
        !            64:           writeSer(&sd,'G');       // CyberMAXX continuous sample mode
        !            65:           cyberenabled=port+1;
        !            66:           return(1);
        !            67:      }
        !            68:      return(0);
        !            69: }
        !            70: 
        !            71: short
        !            72: getserch(struct serialData *s)
        !            73: {
        !            74:      return((short)readSer(s));
        !            75: }
        !            76: 
        !            77: void
        !            78: vio_deinit(void)
        !            79: {
        !            80:      if (iglassenabled) {
        !            81:           deInitSerial(&sd);
        !            82:           iglassenabled=0;
        !            83:      }
        !            84: }
        !            85: 
        !            86: void
        !            87: vio_reset(void)
        !            88: {
        !            89:      writeSer(&sd,'!');
        !            90:      writeSer(&sd,'R');
        !            91:      writeSer(&sd,0x0D);
        !            92: }
        !            93: 
        !            94: void
        !            95: vio_setup(void)
        !            96: {
        !            97:      writeSer(&sd,'!');
        !            98:      writeSer(&sd,'M');
        !            99:      writeSer(&sd,'2');  // cooked data mode
        !           100:      writeSer(&sd,',');
        !           101:      writeSer(&sd,'P');  // polled
        !           102:      writeSer(&sd,',');
        !           103:      writeSer(&sd,'B');  // binary
        !           104:      writeSer(&sd,0x0D);
        !           105: }
        !           106: 
        !           107: int
        !           108: vio_init(int port)
        !           109: {
        !           110:      long delayclock,tries=0;
        !           111: 
        !           112:      if (initSerial(&sd,port,USE_16550,1024,1024) == SER_OK) {
        !           113:           iglassenabled=0;
        !           114:           setBPS(&sd,9600);
        !           115:           vio_reset();
        !           116:           delayclock=totalclock+(CLKIPS>>1);
        !           117:           while (totalclock < delayclock && iglassenabled == 0 && tries < 10) {
        !           118:                if (rxBuffEmpty(&sd)) {
        !           119:                     continue;
        !           120:                }
        !           121:                if (readSer(&sd) == 'O') {
        !           122:                     iglassenabled=port+1;
        !           123:                }
        !           124:                else {
        !           125:                     vio_reset();
        !           126:                     delayclock=totalclock+(CLKIPS>>1);
        !           127:                     tries++;
        !           128:                }
        !           129:           }
        !           130:           if (iglassenabled == 0) {
        !           131:                vio_deinit();
        !           132:                return(0);
        !           133:           }
        !           134:           vio_setup();
        !           135:           return(1);
        !           136:      }
        !           137:      return(0);
        !           138: }
        !           139: 
        !           140: void
        !           141: vio_read(short *yaw,short *pitch,short *roll)
        !           142: {
        !           143:      short c,chk,chk2,yaw2,pitch2,roll2;
        !           144:      long delayclock;
        !           145:      struct serialData *s;
        !           146: 
        !           147:      s=&sd;
        !           148:      flushRead(&sd);
        !           149:      writeSer(&sd,'S');
        !           150:      delayclock=totalclock+(CLKIPS>>3);
        !           151:      while (totalclock < delayclock) {
        !           152:           if (iglassenabled && s->rx.q->count >= 8) {
        !           153:                break;
        !           154:           }
        !           155:           else if (cyberenabled && s->rx.q->count >= 7) {
        !           156:                break;
        !           157:           }
        !           158:      }
        !           159:      chk=0;
        !           160:      pitch2=yaw2=roll2=0;
        !           161:      if ((c=getserch(s)) == 0xFF || cyberenabled) {
        !           162:           if (iglassenabled) {
        !           163:                chk+=c;
        !           164:                yaw2=((c=getserch(s))<<8);    // yaw high byte
        !           165:           }
        !           166:           else {
        !           167:                yaw2=c<<8;
        !           168:           }
        !           169:           chk+=c;
        !           170:           yaw2+=(c=getserch(s));        // yaw low byte
        !           171:           chk+=c;
        !           172:           pitch2=((c=getserch(s))<<8);  // pitch high byte
        !           173:           chk+=c;
        !           174:           pitch2+=(c=getserch(s));      // pitch low byte
        !           175:           chk+=c;
        !           176:           roll2=((c=getserch(s))<<8);   // roll high byte
        !           177:           chk+=c;
        !           178:           roll2+=(c=getserch(s));       // roll low byte
        !           179:           chk+=c;
        !           180:           chk2=getserch(s);             // checksum
        !           181:           if ((chk&0xFF) == chk2 || cyberenabled) {
        !           182:                *yaw=yaw2;
        !           183:                *pitch=pitch2;
        !           184:                *roll=roll2;
        !           185:           }
        !           186:      }
        !           187: }
        !           188: 
        !           189: extern
        !           190: short pitch,
        !           191:      roll,
        !           192:      yaw;
        !           193: 
        !           194: void
        !           195: whvrmon(void)
        !           196: {
        !           197: #if 0
        !           198:      char tmpbuf[80];
        !           199: 
        !           200:      sprintf(tmpbuf,"Y: %05d P: %05d R: %05d C: %05d",yaw,pitch,roll,
        !           201:           sd.rx.q->count);
        !           202:      printext256(0L,8L,31,-1,tmpbuf,1);
        !           203: #endif
        !           204: }
        !           205: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.