'THIS IS THE MARK IV B SOFTWARE FOR THE BASIC STAMP COMPUTER
'VER B.O
'DATE 980325
'REV 981204
'THE STAMP IS CONNECTED TO THE PC VIA AN RS232 SERIAL CONNECTION.  THE
'SERIAL INPUT IS CONNECTED TO PIN 1 TX AND PIN 2 RX OF THE STAMP.
'THIS IS ADDRESSED AS SERIAL I/O PIN 16 IN THE STAMP SOFTWARE
'SERIALDATA IS AN 8 BYTE FIELD THAT RECEIVES SERIAL DATA FROM THE PC AND
'HOLDS REVISED DATA FOR TRANSMISSION BACK TO THE PC.  IN GENERAL A COMMAND
'IS SENT TO THE STAMP AS AN 8 BYTE STRING.  THE LEADING AND TRAILING BYTES
'ARE THE VERSION AND SUB VERSION.  THE TRANSMITTED BYTES MUST MATCH THE
'STORED VERSION IN THE STAMP'S PROM.  THE STAMP ALWAYS ANSWERS WITH THE
'VERSION STORED IN ITS PROM.  THIS WAY, THE STAMP CAN DO NOTHING BUT REPLY
'WITH IT'S VERSION NUMBER WHEN IT RECEIVES A MESSAGE FOR THE WRONG VERSION.
'LIKEWISE, THE PC CAN CHECK VERSION NUMBER FROM THE REPLY AND WILL KNOW
'THAT THERE WAS NO RESPONSE TO A COMMAND WITH THE WRONG VERSION.
'
'THE INSTRUCTION FIELD CONTAINS AN INSTRUCTION AND A SUB INSTRUCTION.  THE
'INSTRUCTION WILL BRANCH TO ONE OF THE MAIN ROUTINES.  THE SUB INSTRUCTION
'WILL DETERMINE WHAT IS DONE IN THE ROUTINE.
'
'ALL ROUTINES ARE PLACED IN ALPHABETICAL ORDER.  SOME ARE SPAGHETTI CODE
'ENTERED WITH A LABEL AND EXITED WITH A GOTO.  THIS IS FORCED BY THE STAMP
'DESIGN.  IN GENERAL WE WAIT FOR A SERIAL COMMAND WHICH BRANCHES INTO
'THE ROUTINES BASED ON THE COMMAND IN INSTR0. THEN WE GO BACK TO LOOKING
'FOR THE NEXT SERIAL INSTRUCTION AT WAITFORSERIN AFTER SENDING A REPLY
'
'WHILE THIS IS SPAGHETTI, THERE IS ONLY ONE LEVEL OF SPAGHETTI

'********** THE VARIABLE ASSIGNMENTS *********************
'VARIABLE ASSIGNMENTS
'
'THE STAMP LETS YOU REFER TO WORDS, BYTES, NIBBLES AND BITS JUST BY
'DEFINING THE VARIABLES.  THIS IS FREE IN THAT IT USES NO SPACE SO
'ALL THE EXCESSIVE VARIABLE ASSIGNMENTS BELOW ALLOW REFERENCE TO BITS
'WHERE NEEDED WITHOUT JUST DEFINING THE SPECIFIC VARIABLES USED.
'
SERIALDATA VAR BYTE(8)  'THIS HOLDS THE ASCII STRING SENT FROMTHE PC
INDEX VAR WORD          'GP VARIABLE FOR LOOPS
SENSEREG VAR WORD       'HOLDS SENS BITS
REGISTER VAR WORD       'HOLDS THE LOAD VALUE FOR A REGISTER
INST0 VAR BYTE          'BREAK DOWN OF THE ASCII STRING BY USE
INST1 VAR BYTE
DATA0 VAR BYTE
DATA1 VAR BYTE
DATA2 VAR BYTE
DATA3 VAR BYTE
TIMEOUTX VAR BYTE       'HOLDS THE NUMBER OF TIMES THE SERIN FROM THE PC
                         'TIMES OUT
TEMP VAR BYTE           'GENERAL PURPOSE VARIABLE
TEMPA VAR BYTE          'GENERAL PURPOSE VARIABLE
POSITION VAR NIB
DIRECTION VAR BIT
LIMITON VAR BIT         'MOTOR LIMIT IS ON
MOTORID VAR NIB
'THE LOCATIONS OF THE RECEIVED ASCII STRING
'
INST00 VAR INST0.NIB0   'NIBBLES OF THE RECEIVED ASCII STRING.  ONLY
INST10 VAR INST1.NIB0   'THE LOW ORDER NIBBLE OF EACH IS USED SO THAT
DATA00 VAR DATA0.NIB0   'WE DO NOT GET IN TROUBLE WITH PC'S THAT DON'T
DATA10 VAR DATA1.NIB0   'LIKE TO SEND ALL POSSIBLE ASCII CHARACTERS
DATA20 VAR DATA2.NIB0   'WE WILL USE ASCII CHARACTERS STARTING WITH
DATA30 VAR DATA3.NIB0   '&H30 WHICH ARE NUMBERS STARTING WITH 0 AND
                         'CONTINUING THROUGH ?


DATA000 VAR DATA00.BIT0
DATA001 VAR DATA00.BIT1
DATA002 VAR DATA00.BIT2
DATA003 VAR DATA00.BIT3
DATA100 VAR DATA10.BIT0
DATA101 VAR DATA10.BIT1
DATA102 VAR DATA10.BIT2
DATA103 VAR DATA10.BIT3
DATA200 VAR DATA20.BIT0
DATA201 VAR DATA20.BIT1
DATA202 VAR DATA20.BIT2
DATA203 VAR DATA20.BIT3
DATA300 VAR DATA30.BIT0
DATA301 VAR DATA30.BIT1
DATA302 VAR DATA30.BIT2
DATA303 VAR DATA30.BIT3

REGISTER0 VAR REGISTER.NIB0
REGISTER1 VAR REGISTER.NIB1
REGISTER2 VAR REGISTER.NIB2
REGISTER3 VAR REGISTER.NIB3
SENSEREG0 VAR SENSEREG.NIB0
SENSEREG1 VAR SENSEREG.NIB1
SENSEREG2 VAR SENSEREG.NIB2
SENSEREG3 VAR SENSEREG.NIB3
TEMP0 VAR TEMP.NIB0
TEMP1 VAR TEMP.NIB1
TEMP10 VAR TEMP.BIT0
TEMP11 VAR TEMP.BIT1
TEMP12 VAR TEMP.BIT2
TEMP13 VAR TEMP.BIT3
TEMP14 VAR TEMP.BIT4
TEMP15 VAR TEMP.BIT5
TEMP16 VAR TEMP.BIT6
TEMP17 VAR TEMP.BIT7
'
'CONSTANT ASSIGNMENTS
'
'INITIAL VALUES OF THE VARIOUS REGISTERS.
SUBVERSION CON "0"          'AND SUB VERSION NUMBER/LETTER
VERSION CON "B"             'REPLACE WITH CURRENT VERSION
STEPZERO0 CON  %00000001   '0   0A  BIT POSITION-CHANNEL
STEPONE0 CON   %00000000   '1   3B
STEPTWO0 CON   %10000000   '2   1A
STEPTHREE0 CON %10000001   '3   2B
STEPZERO1 CON  %00000100   '4   2A
STEPONE1 CON   %00000000   '5   1B
STEPTWO1 CON   %00100000   '6   3A
STEPTHREE1 CON %00100100   '7   0B
STEPZERO2 CON  %00010000
STEPONE2 CON   %00000000
STEPTWO2 CON   %00001000
STEPTHREE2 CON %00011000
STEPZERO3 CON  %01000000
STEPONE3 CON   %00000000
STEPTWO3 CON   %00000010
STEPTHREE3 CON %01000010

'*************************************************************
'******* THE PROGRAM STARTS HERE *****************************
'NOW GO OFF AND INITIALIZE EVERYTHING.
GOTO STARTUP

'****************************************************************
'BELOW ARE ALL THE ROUTINES IN ALPHABETICAL ORDER.  SOME ARE GOSUB/
'RETURNS.  OTHERS ARE ENTERED BY A BRANCH OF A PRIMARY INSTRUCTION.
'THESE DO A PROCESS THEN GOTO ENDUP.  ENDUP SENDS A RESPONSE TO THE
'PC, THEN GOES TO WAITFORSERIN TO GET THE NEXT INSTRUCTION.
'********************ADC***************************************
'READS AN ADC CHANNEL
ADC:
GOSUB BUSOUT                'MAKE BUS AN OUTPUT
OUTH = $F2                  'PULSE SELECT VALUE TO LOAD MPX SELECT
HIGH 7
LOW 7                       'PUT IT IN PULSE SELECT
GOSUB LOADBUS0              'PUT DATA0,1 ON BUS
HIGH 6
LOW 6                       'PUT DATA0,1 IN MPX SELECT REGISTER
OUTH = $D8                  'PULSE SELECT VALUE TO START ADC
HIGH 7
LOW 7                       'PUT IT IN PUSLE SELECT REG
HIGH 6
LOW 6                       'NOW PULSE STARTS ADC
OUTH = $F0                  'PULSE SELECT VALUE TO SELECT HIGH BYTE
HIGH 7
LOW 7                       'LOAD HIGH BYTE SELECTION
GOSUB BUSIN                 'TURN BUS AROUND TO INPUT DATA
LOW 3                       'ENABLE ADC DATA TO BUS
GOSUB UNLOAD0               'PUT THE HIGH BYTE IN DATA0,1
HIGH 3                      'DISABLE ADC DAT TO BUS
GOSUB BUSOUT                'BUS BACK TO OUTPUT
OUTH = $00                  'TO SELECT LOW BYTE
HIGH 7
LOW 7                       'LOAD LOW BYTE SELECTION
GOSUB BUSIN
LOW 3
GOSUB UNLOAD1               'PUT THE LOW BYTE IN DATA DATA2,3
HIGH 3
GOSUB BUSOUT                'ALWAYS LEAVE BUS IN OUTPUT
GOTO ENDUP



'*****BUSIN***************************************************
'MAKE THE CONTROL CARD 8 BIT BUS AN INPUT BUS
BUSIN:
DIR8 = %0
DIR9 = %0
DIR10 = %0
DIR11 = %0
DIR12 = %0
DIR13 = %0
DIR14 = %0
DIR15 = %0
RETURN

'*****BUSOUT**************************************************
'MAKE THE CONTROL CARD 4 BIT BUS AN OUTPUT BUS
BUSOUT:
DIR8 = %1
DIR9 = %1
DIR10 = %1
DIR11 = %1
DIR12 = %1
DIR13 = %1
DIR14 = %1
DIR15 = %1
RETURN

'*****DECLINATION**************************************************
'MOVE TO SPECIFIED POSITION IN DECLINATION.  MOVE A NUMBER OF STEPS IN
'A PARTICULAR DIRECTION.  MOVE TO A SPECIFIED NUMBER OF STEPS FROM A
'LIMIT
'*****ENDUP*******************************************************
'SEND A SERIAL MESSAGE BACK TO THE PC CONTAINING AT LEAST THE CURRENT
'SOFTWARE VERSION NUMBER
ENDUP:
'PAUSE 400    'IF WE REPLY TOO QUICKLY, THE PC IS NOT READY FOR IT
TIMEOUTX=%0
SERIALDATA(1)=INST0
SERIALDATA(2)=INST1
SERIALDATA(3)=DATA0
SERIALDATA(4)=DATA1
SERIALDATA(5)=DATA2
SERIALDATA(6)=DATA3
SEROUT 16,84+$4000,["S"]
SEROUT 16,84+$4000,[STR SERIALDATA\8]
GOTO WAITFORSERIN

'*****FOCUS****************************************************
'MOVE TO A SPECIFIED FOCUS POSITION 0 TO 255 POSITION IS IN DATA0
FOCUS:
GOTO ENDUP

'*****LOADADAC****************************************************
'LOAD A SELECTED DAC WITH A SELECTED VALUE.  DATA00 SELECTS OCTAL DAC.
'DATA10 SELECTS THE DAC CHANNEL.  DATA20(HO) AND DATA30 (LO) ARE THE
'VALUE TO LOAD   &H32 IN INST00 GETS US HERE  WE WILL ASSEMBLE THE
'STRING TO SEND TO THE DAC IN THE WORD TEMP0.  THIS VERSION FOR THE
'MARK IV HANDLES ONLY THE FIRST 8 DACS.  DATA10 IS PRE ASSEMBLED IN
'THE PC TO SHOW GAIN AND DAC NUMBER
LOADADAC:
REGISTER0 = DATA30
REGISTER1 = DATA20
REGISTER2 = DATA10
SHIFTOUT 5,4,1,[REGISTER\12] 'SEND BITS 11 - 0 TO DAC
BRANCH INST10, [LDA,LDB]
LDA:
OUTH = $F8          'PULSE PATH TO LOAD DAC A
HIGH 7
LOW 7               'LOAD PATH
HIGH 6
LOW 6               'LOAD DAC A
GOTO ENDUP
LDB:
OUTH = $D2          'PULSE PATH TO LOAD DAC B
HIGH 7
LOW 7               'LOAD PATH
HIGH 6
LOW 6               'LOAD DAC B
GOTO ENDUP
'******************LOADBUS0***************************
'LOAD THE 8 BIT BUS FROM DATA0 AND DATA1
LOADBUS0:
OUT8 = DATA100
OUT9 = DATA101
OUT10 = DATA102
OUT11 = DATA103
OUT12 = DATA000
OUT13 = DATA001
OUT14 = DATA002
OUT15 = DATA003
RETURN
'******************LOADBUS1*************************
'LOAD THE 8BIT BUS FROM DATA2 AND DATA3
LOADBUS1:
OUT8 = DATA300
OUT9 = DATA301
OUT10 = DATA302
OUT11 = DATA303
OUT12 = DATA200
OUT13 = DATA201
OUT14 = DATA202
OUT15 = DATA203
RETURN
'*****************LOADBUSTEMP**********************
'LOAD THE 8BIT BUS FROM TEMP
LOADBUSTEMP:
OUT8 = TEMP10
OUT9 = TEMP11
OUT10 = TEMP12
OUT11 = TEMP13
OUT12 = TEMP14
OUT13 = TEMP15
OUT14 = TEMP16
OUT15 = TEMP17
RETURN
'*****************LOADREGISTER*******************************
'PUTS THE VALUE ON DATA2 AND DATA3 INTO THE REGISTER DETERMINED
'BY PULSEPATH
LOADREGISTER:
GOSUB PULSEPATH             'LOADS DATA1, DATA0 IN PULSE PATH
GOSUB LOADBUS1              'PUTS DATA2, DATA3 ON BUS
HIGH 6                      'LOADS REGISTER INDICATED BY PULSEPATH
LOW 6
GOTO ENDUP
'****************MASERVO************************************
'DATA0 AND DATA1 CONTAIN THE PULSE PATH TO THE DESIRED SERVO
'INST0 IS 7
MASERVO:
GOSUB PULSEPATH
LOW 6      'MAKE SURE WE START WITH PIN 6 HIGH
REGISTER = 4*(DATA30+(16*DATA20))+2
'O IN DATA30 (LO) AND DATA20 GIVES 1MS, 255 GIVES (ROUGHLY) 2MS
FOR INDEX = 1 TO 50
PULSOUT 6, REGISTER
PAUSE 20
NEXT
GOTO ENDUP
'*************MOVENSTEPS*************************************
'INST 9,2
MOVENSTEPS:
'DATA00 TO DATA30 CONTAIN THE NUMBER OF STEPS
STEPPERSTEP:
REGISTER0=DATA30   'PUT COUNT IN REGISTER
REGISTER1=DATA20
REGISTER2=DATA10
REGISTER3=DATA00
FOR INDEX = 1 TO REGISTER
GOSUB STEPITONE
NEXT
GOTO ENDUP
'*************MOVETOLIMIT***********************************
'INST 9,3
MOVETOLIMIT:
REGISTER0=DATA30   'PUT MASK IN REGISTER
REGISTER1=DATA20
REGISTER2=DATA10
REGISTER3=DATA00
FOR INDEX = 1 TO 5000   'NO MORE THAN 5000 TRIES
GOSUB STEPITONE
GOSUB SENSEIT
SENSEREG0=DATA30  'PUT MASK BITS INTO SENSEREG
SENSEREG1=DATA20
SENSEREG2=DATA10
SENSEREG3=DATA00
IF SENSEREG & REGISTER >0 THEN ENDUP 'COMPARE SENSE WITH MASK
NEXT
'PUT A FAILURE ROUTINE HERE
GOTO ENDUP
'*************PULSE*******************************************
PULSE:
BRANCH INST10, [PULSE1]
GOTO ENDUP  'IN CASE WE GET HERE
'*************PULSE1*****************************************
'HERE TO PULSE ONCE
PULSE1:
GOSUB PULSEPATH
HIGH 6        'MAKE PULSE ON SELECTED LINE
LOW 6
GOTO ENDUP
'***************PULSEPATH*********************************
'SETS UP PULSE PATH BASED ON THE ADDRESS IN DATA0 AND DATA1
PULSEPATH:
GOSUB LOADBUS0        'PUT DATA0 AND DATA1 ON BUS
GOSUB BUSOUT          'SET TO OUT
HIGH 7
LOW 7                 'MAKE HIGH LOW PULSE TO LOAD PULSE SELECT REG
RETURN
'*****SENSE****************************************************
'READS ALL THE SENSE INPUTS. 'THE VALUES ARE RETURNED IN DA0, DA1
'DA2, DA3.. LITTLE ENDIAN STYLE I.E. SENSE 0 IN BIT O OF DA1
SENSE:
GOSUB SENSEIT
GOTO ENDUP
SENSEIT:
GOSUB BUSIN
LOW 1
GOSUB UNLOAD1  'LOW BYTE INTO DATA2, DATA3
HIGH 1
LOW 0
GOSUB UNLOAD0  'HIGH BYTE INTO DATA0, DATA1
HIGH 0
GOSUB BUSOUT
RETURN
'*************SETUPMOTOR***********************************
'INST 9,5
SETUPMOTOR:
DIRECTION = DATA000
MOTORID = DATA10
GOTO ENDUP
'************STEPPERROUTE************************************
'GO TO THE SELECTED SUB INSTRUCTION  9,N
STEPPERROUTE:
BRANCH INST10, [LOADREGISTER,LOADREGISTER,MOVENSTEPS,MOVETOLIMIT,SETUPMOTOR]
GOTO ENDUP
'*********STEPONE*****************************************
'MOVE THE SETUP NUMBER OF STEPS OF THE SELECTED MOTOR IN THE
'SETUP DIRECTION  9,1
STEPITONE:
BRANCH MOTORID, [STEPITONE0,STEPITONE1,STEPITONE2,STEPITONE3]
STEPITONE0:
IF DIRECTION = 1 THEN FORWARD0
IF POSITION = 0 THEN STEP30
IF POSITION = 1 THEN STEP00
IF POSITION = 2 THEN STEP10
IF POSITION = 3 THEN STEP20
FORWARD0:
IF POSITION = 0 THEN STEP10
IF POSITION = 1 THEN STEP20
IF POSITION = 2 THEN STEP30
IF POSITION = 3 THEN STEP00
STEP00:
TEMP=STEPZERO0
POSITION = 0
GOTO LOADMOTORDRIVES
STEP10:
TEMP=STEPONE0
POSITION = 1
GOTO LOADMOTORDRIVES
STEP20:
TEMP=STEPTWO0
POSITION = 2
GOTO LOADMOTORDRIVES
STEP30:
TEMP=STEPTHREE0
POSITION = 3
GOTO LOADMOTORDRIVES

STEPITONE1:
IF DIRECTION = 1 THEN FORWARD1
IF POSITION = 0 THEN STEP31
IF POSITION = 1 THEN STEP01
IF POSITION = 2 THEN STEP11
IF POSITION = 3 THEN STEP21
FORWARD1:
IF POSITION = 0 THEN STEP11
IF POSITION = 1 THEN STEP21
IF POSITION = 2 THEN STEP31
IF POSITION = 3 THEN STEP01
STEP01:
TEMP=STEPZERO1
POSITION = 0
GOTO LOADMOTORDRIVES
STEP11:
TEMP=STEPONE1
POSITION = 1
GOTO LOADMOTORDRIVES
STEP21:
TEMP=STEPTWO1
POSITION = 2
GOTO LOADMOTORDRIVES
STEP31:
TEMP=STEPTHREE1
POSITION = 3
GOTO LOADMOTORDRIVES

STEPITONE2:
IF DIRECTION = 1 THEN FORWARD2
IF POSITION = 0 THEN STEP32
IF POSITION = 1 THEN STEP02
IF POSITION = 2 THEN STEP12
IF POSITION = 3 THEN STEP22
FORWARD2:
IF POSITION = 0 THEN STEP12
IF POSITION = 1 THEN STEP22
IF POSITION = 2 THEN STEP32
IF POSITION = 3 THEN STEP02
STEP02:
TEMP=STEPZERO2
POSITION = 0
GOTO LOADMOTORDRIVES
STEP12:
TEMP=STEPONE2
POSITION = 1
GOTO LOADMOTORDRIVES
STEP22:
TEMP=STEPTWO2
POSITION = 2
GOTO LOADMOTORDRIVES
STEP32:
TEMP=STEPTHREE2
POSITION = 3
GOTO LOADMOTORDRIVES

STEPITONE3:
IF DIRECTION = 1 THEN FORWARD3
IF POSITION = 0 THEN STEP33
IF POSITION = 1 THEN STEP03
IF POSITION = 2 THEN STEP13
IF POSITION = 3 THEN STEP23
FORWARD3:
IF POSITION = 0 THEN STEP13
IF POSITION = 1 THEN STEP23
IF POSITION = 2 THEN STEP33
IF POSITION = 3 THEN STEP03
STEP03:
TEMP=STEPZERO3
POSITION = 0
GOTO LOADMOTORDRIVES
STEP13:
TEMP=STEPONE3
POSITION = 1
GOTO LOADMOTORDRIVES
STEP23:
TEMP=STEPTWO3
POSITION = 2
GOTO LOADMOTORDRIVES
STEP33:
TEMP=STEPTHREE3
POSITION = 3
GOTO LOADMOTORDRIVES

LOADMOTORDRIVES:
'FIRST SETUP PULSE PATH TO LOAD MOTOR DRIVE #1
DATA0 = "7"
DATA1 = "9"
'LOAD THE PULSE PATH
GOSUB PULSEPATH 'LOADS PATH TO MOTOR DRIVE #1
'PUT NEW SEQUENCE ON BUS
GOSUB LOADBUSTEMP
HIGH 6
LOW 6  'LOAD MOTOR DRIVE #1
'NOW SETUP PULSE PATH TO LOAD MOTOR DRIVE #2
DATA0 = "7"
DATA1 = "1"
'LOAD THE PULSE PATH
GOSUB PULSEPATH
'PUT NEW SEQUENCE ON BUS
GOSUB LOADBUSTEMP
'LOAD IT INTO MOTOR DRIVE #2
HIGH 6
LOW 6
RETURN
'*****STARTUP*****************************************************
'HERE WE PUT ALL THE RIGHT BITS IN ALL THE RIGHT REGISTERS TO START
'THINGS UP PROPERLY.  BUS IS OUTPUT, MOTOR CURRENTS OFF, WHAT ELSE?
'STAMP LINES] USED TO MAKE PULSES ARE SET INITIALLY AT HIGH SO A LOW
'HIGH WILL MAKE A LOAD PULSE TO THE 161 REGISTERS
'FIRST MAKE SURE THE ADC OUTPUTS ARE NOT ENABLED ONTO THE 4 BIT BUS
'BY DISABLING ALL FOUR NIBBLE SELECTIONS OTHERWISE THERE MAY BE A
'BUS READ/WRITE CONFLICT
'NOW TURN OFF THE MOTORS
'GO OFF TO WAIT FOR AN INSTRUCTION
STARTUP:
HIGH 0
HIGH 1
LOW 2
HIGH 3
LOW 4
LOW 5
LOW 6
LOW 7
DIRL=$FF'  CHANGE TO GOSUB BUSOUT
GOTO WAITFORSERIN

'*****TEST******************************************************
'HERE WE WILL INVENT SOME UTILITY TESTS
'INST10 IS DECODED INTO DIFFERENT OPERATIONS.
'PULSE PUTS ONE PULSE OUT ON THE PULSE LINE DETERMINED BY DATA0,DATA1
'LOADREGISTER LOADS VALUE IN DATA2,DATA3 INTO REGISTER DETERMINED BY
'DATA0,DATA1
'ENDUP LOOPS BACK THE TRANSMITTES CHARACTERS
TEST:
BRANCH INST10, [PULSE,LOADREGISTER,ENDUP]
GOTO ENDUP

'*****TIMEOUT******************************************************
'WE HAVE TIMED OUT WITHOUT A MESSAGE FROM THE PC IF WE GET HERE.  NOW DO
'THE DEAD MAN ROUTINE AND TRY TO GET THINGS GOING AGAIN.  TURN OFF POWER
'TO THE PC AND FORCE A REBOOT.  NOTE THE STAMP IS IN CONTROL.  ITS CODE IS
'SUPPOSED TO BE FOOL PROOF AS IT IS SMALL AND DOES SIMPLE THINGS.  MOSTLY
'LOOPS AROUND A SERIN.  SO IT IS ALWAYS WAITING IN A SERIN LOOP UNLESS
'ACTUALLY DOING SOMETHING.  TO KEEP THE DEAD MAN FROM ACTIVATING, THE
'PC MUST TALK TO THE STAMP ONCE A MINUTE.  IF IT DOES NOT, THEN THE STAMP
'TURNS OFF THE POWER TO THE PC.  ON A POWER OUTAGE (THE STAMP WILL HAVE
'BACKUP POWER) THE STAMP WILL NOTICE THAT THE PC IS NOT SENDING THE ONCE A
'MINUTE MESSAGE AND WILL BE TRYING TO POWER DOWN AND UP THE POWERED DOWN
'PC.  NOTHING WILL BE HAPPENING BECAUSE ONLY THE STAMP WILL HAVE POWER.
'IT WILL KEEP DOING THIS UNTIL THE POWER RETURNS, AT WHICH POINT THE PC
'WILL START UP DOING IT'S INITIALIZATION ROUTINE AND EVERYTHING WILL BE OK.
'(NOTE TO ME - WE WILL NEED AN ON/OFF SWITCH TO THE BATTERY OR THE STAMP
'WILL RUN THE BATTERY DOWN WHEN OFF FOR LONG PERIODS - BUT MAYBEE OK IF
'WE USE A NICAD)
TIMEOUT:
'PUT THE RECOVERY ROUTINE HERE I.E. REBOOT THE PC COMPUTER
GOTO WAITFORSERIN

'*****TIMEOUT1*******************************************************
'HERE WE CHECK FOR LIMIT SWITCHES, OVER TEMPERATURES, WATER ON, ETC.,
'IF WE GET HERE TOO MANY TIMES WITHOUT SERIAL DATA, THEN GO TO TIMEOUT
'AND TRY TO RECOVER
TIMEOUT1:
TIMEOUTX = TIMEOUTX + 1
IF TIMEOUTX >= 10 THEN ENDUP
GOTO WAITFORSERIN
'********************UNLOAD0*********************************
'PUTS INPUT BUS DATA INTO DATA0,1
UNLOAD0:
DATA000 = IN15
DATA001 = IN13
DATA002 = IN11
DATA003 = IN9
DATA100 = IN8
DATA101 = IN10
DATA102 = IN12
DATA103 = IN14
RETURN
'********************UNLOAD1********************************
'PUTS INPUT BUS DATA INTO DATA2,3
UNLOAD1:
DATA200 = IN15
DATA201 = IN13
DATA202 = IN11
DATA203 = IN9
DATA300 = IN8
DATA301 = IN10
DATA302 = IN12
DATA303 = IN14
RETURN

'*****WAITFORSERIN**************************************************
'MOST THINGS START HERE WITH INPUT OF A STRING OF 8 BYTES FROM THE
'PC.  THIS IS DECODED INTO INSTRUCTIONS AND DATA.   THE PROGRAM THEN
'BRANCHES OFF TO DO THE INSTRUCTION.  SOMETIMES THERE IS A SECOND BRANCH
'FOR THE SUB INSTRUCTION
WAITFORSERIN:
SERIN 16,84+$4000,1000,TIMEOUT1,[STR SERIALDATA\8] 'WAS 84 FOR 9600
TIMEOUTX=%0  'HAVE RECEIVED SERIAL IN SO RESET TIMEOUT
INST0 = SERIALDATA(1)
INST1 = SERIALDATA(2)
DATA0 = SERIALDATA(3)
DATA1 = SERIALDATA(4)
DATA2 = SERIALDATA(5)
DATA3 = SERIALDATA(6)
'HERE CHECK THE VERSION IS THE PROPER ONE
BRANCH 
INST00,[TEST,LOADADAC,ADC,PULSE,TEST,TEST,SENSE,MASERVO,TEST,STEPPERROUTE]
'DECLINATION    LOADADAC        ADC             PULSE
'RADRIVE        READADC         SENSE           MASERVO
'TEST           STEPPERROUTE
GOTO ENDUP 'IN CASE WE GET HERE