Driving the AD9850 signal generator with a picaxe

#picaxe20x2
setfreq m64
#simspeed 0
'
' Calculates 32 bit data load for frequency on AD9850
' accurate to 0.01%
' 32-Bit (unsigned) maths on a PICAXE   
' J.Leach 2006 , modified PM 26/10/2012  
'
Symbol Procedure0StartAddress = 0
Eeprom 0,("+E*F*G/H=I")
'Word 0 (b0 and b1)
Symbol OperandLSW = w0
Symbol OperandLSWLSB = b0
Symbol OperandLSWMSB = b1
'Word 1 (b2 and b3)
Symbol T = w1
Symbol Temp2Word = w1
Symbol InstructionOperand = b2
'Word 2 (b4 and b5)
Symbol AccumulatorLSW = w2
Symbol AccumulatorLSWLSB = b4
Symbol AccumulatorLSWMSB = b5
'Word 3 (b6 and b7)
Symbol AccumulatorMSW = w3
'Word 4 (b8 and b9)
Symbol S = w4
Symbol Temp1Word = w4
'Word 5 (b10 and b11)
Symbol OperandMSW = w5
Symbol Address = b10
Symbol Address1 = b10
Symbol Address2 = b11
'Word 6 (b12 and b13)
Symbol InstructionCode = b12
Symbol Temp1Byte = b12
Symbol ProgramCounter = b13
Symbol Temp2Byte = b13
Symbol ErrorFlag = b13
Symbol Index = b13
'words 7-11
symbol E=w7
symbol F=w8
symbol G=w9
symbol H=w10
symbol I=w11
symbol Decade =w12
symbol byte0=0
symbol byte1=b4
symbol byte2=b5
symbol byte3=b6
symbol byte4=b7
symbol Crystalmult=10000
Symbol LCDOutPin = 6 'LCD used for alerting, but other methods can be used.
Symbol RTStartAddress = 80
Symbol RTEndAddress = 83
Symbol DenominatorLSBAddress = 84
Symbol DenominatorMSBAddress = 85
Symbol ErrorFlagAddress = 86
Symbol GPRStartAddress = 88
Symbol ProgramCounterAddress = 87
Symbol ERROR_Overflow = 0
Symbol ERROR_NegativeResult = 1
Symbol ERROR_DivideByZero = 2
Symbol RTStartLessb4Address = 76 '(80 - 4)
Symbol GPRStartAddressLessb0Address = 88 '(87 - 0)

Main:
Decade=100 'Multiply base frequency by this to get target frequency
'1, 10, 100, 1000, 10000 are valid values for the decade multiplier
E = 5000 ' base frequency set for 500Khz (5000 * 100)
'1-9999  are valid values for the base frequency
F = 42950 'approx 2^32/1000000
G = 8 'scale to use max precision for 125MHz crystal (1,000,000,000/125,000,000)
H = 10000/Decade 'scale the answer based on the decade selected
ProgramCounter = Procedure0StartAddress
Gosub ExecuteProcedure
'
'substitute serial or parallel chip load here based on hardware I/F selected
'
b0=byte4
gosub writehex 
b0=byte3
gosub writehex
b0=byte2
gosub writehex
b0=byte1
gosub writehex
End

 '*************************************************
 '**** VIRTUAL ARITHMETIC AND LOGIC UNIT (ALU) ****
 '*************************************************

Add:

      Poke ErrorFlagAddress,ERROR_Overflow

      'Add LSW
      AccumulatorLSW = AccumulatorLSW + OperandLSW
      If AccumulatorLSW >= OperandLSW Then Add_1
      'Add Carry to MSW and jump to error routine if overflow
      AccumulatorMSW = AccumulatorMSW + 1
      If AccumulatorMSW = 0 Then CPU_Error

      'Add MSW
      Add_1:
      AccumulatorMSW = AccumulatorMSW + OperandMSW
      'Jump to error routine if overflow
      If AccumulatorMSW < OperandMSW Then CPU_Error
Return

Subtract:
      Poke ErrorFlagAddress,ERROR_NegativeResult

      'Subtract LSW
      Temp1Word = AccumulatorLSW
      AccumulatorLSW = AccumulatorLSW - OperandLSW

      If Temp1Word >= AccumulatorLSW Then Subtract_1
      'Borrow from MSW and jump to error routine if this will make the overall result
      'negative.
      If AccumulatorMSW = 0 Then CPU_Error
      AccumulatorMSW = AccumulatorMSW - 1

      'Note: No need to Subtract MSW as only OperandLSW is being used
      Subtract_1:
Goto Fetch

Multiply:

      Poke ErrorFlagAddress,ERROR_Overflow

      'Calculate the higher multiple and keep in Accumulator
      Temp1Word = AccumulatorLSW
      Temp2Word = AccumulatorMSW
      AccumulatorLSW = 0
      AccumulatorMSW = OperandLSW * Temp2Word
      Temp2Word = OperandLSW ** Temp2Word
      'Check for overflow
      If Temp2Word > 0 Then CPU_Error

      'Calculate the lower multiple and put in Operand
      OperandMSW = Temp1Word ** OperandLSW
      OperandLSW = Temp1Word * OperandLSW

      'Add the multiples to get the final result
      Gosub Add
Goto Fetch

Divide:
      Poke ErrorFlagAddress,ERROR_DivideByZero

      'Check for error
      If OperandLSW = 0 Then CPU_Error

      'Zero the Running Total
      For Address = RTStartAddress To RTEndAddress
            Poke Address,0
      Next

      'Calculate the quotient and remainder for 65535/OperandLSW
      S = 65535 / OperandLSW
      T = 65535 // OperandLSW

      'Store the denominator
      Poke DenominatorLSBAddress,OperandLSWLSB
      Poke DenominatorMSBAddress,OperandLSWMSB

      Divide_1:
      'Calculate S * AccumulatorMSW in the Operand, and add to Running Total.
      'Note: uses variables very carefully !
      OperandLSW = AccumulatorMSW
      Gosub SwapAccumulatorWithRT
      OperandMSW = S ** OperandLSW
      OperandLSW = S * OperandLSW
      Gosub Add
      'Update the running total
      Gosub SwapAccumulatorWithRT

      'Calculate the new Numerator
      OperandMSW = 0
      OperandLSW = AccumulatorLSW + AccumulatorMSW
      If OperandLSW > AccumulatorMSW Then Divide_2
      OperandMSW = 1
      Divide_2:
      AccumulatorLSW = AccumulatorMSW * T
      AccumulatorMSW = AccumulatorMSW ** T
      Gosub Add

      'Check to see if the new numerator is a single word. Loop back if it isn't
      If AccumulatorMSW > 0 Then Divide_1

      Temp1Word = AccumulatorLSW
      'Retrieve the running total
      Gosub SwapAccumulatorWithRT
      'Retrieve the denominator
      Peek DenominatorLSBAddress,OperandLSWLSB
      Peek DenominatorMSBAddress,OperandLSWMSB
      'Calculate AccumulatorLSW/Demominator and store in Operand
      OperandLSW = Temp1Word / OperandLSW
      OperandMSW = 0
      'and add to the Running total to give the final result
      Gosub Add
Goto Fetch

SwapAccumulatorWithRT:
      'Swaps the Accumulator value with the Running Total value
      For Address1 = RTStartAddress To RTEndAddress
            Address2 = Address1 - RTStartLessb4Address
            Peek Address1,Temp1Byte
            Peek Address2,Temp2Byte
            Poke Address1,Temp2Byte
            Poke Address2,Temp1Byte
      Next
Return

StoreAccumulatorLSW:

      Address = InstructionOperand - "E" * 2 +14
      Poke Address,AccumulatorLSWLSB
      Address = Address + 1
      Poke Address,AccumulatorLSWMSB
Return

CPU_Error:
      Peek ErrorFlagAddress,ErrorFlag
      Sertxd("ERROR: ",#ErrorFlag," ")
End

ExecuteProcedure:
      'ON ENTRY: ProgramCounter has been set to the start of the Procedure

      'Save the Program Counter
      Poke ProgramCounterAddress,ProgramCounter 'Save the ProgramCounter

      'Load General Purpose registers with corresponding E to I4 values
      For Address1 = 14 To 23
            Address2 = Address1 + GPRStartAddress -14
            Peek Address1,Temp1Byte
            Poke Address2,Temp1Byte
      Next

      'Set the Accumulator to 0
      AccumulatorMSW = 0
      AccumulatorLSW = 0

Fetch:
      'Fetch an Instruction code and operand from Program Memory
      Peek ProgramCounterAddress,ProgramCounter 'Retrieve the ProgramCounter
      Read ProgramCounter,InstructionCode
      ProgramCounter = ProgramCounter + 1
      Read ProgramCounter,InstructionOperand
      ProgramCounter = ProgramCounter + 1
      Poke ProgramCounterAddress,ProgramCounter 'Save the ProgramCounter

      'Load the contents of the specified Register into OperandLSW
      Address = InstructionOperand - "E" * 2 + GPRStartAddress
      Peek Address,OperandLSWLSB
      Address = Address + 1
      Peek Address,OperandLSWMSB
      OperandMSW = 0

Execute:
      'Execute the loaded Instruction

      Lookdown InstructionCode,("+","-","*","/","="),Index
      Branch Index,(Instruction_Add,Subtract,Multiply,Divide,StoreAccumulatorLSW)

Instruction_Add:
      Gosub Add
      Goto Fetch 

writehex:
     b1=b0>>4
     gosub hexit
     sertxd (b1)
     b1=b0 & $0F
     gosub hexit
     sertxd (b1,cr,lf)
return

hexit:
     lookup b1,("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"),b1
return