Return to whctm.c CVS log

Up to [Witchaven I] / src

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

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