; full cycle 2.1
; originates from full cycle
; version 2 has many more segments, allowing it to actually dip simple candles
; version 2.1 is just a branch to preserve the old code, just in case
  
;variables
.equ lineSegmentIndex, 0x20 ;the acceleration curve is made of 4 line segments having deltas of 8,4,2,1
.equ sixteenSpeedsIndex, 0x21 ;index for moving through the 16 speeds within each line segment
.equ stepIndex, 0x22 ;index for the loop that actually causes some motor movement.
.equ numSteps, 0x23 ;number of steps to send to the motor in this loop iteration.
.equ delayTimeDelta, 0x24 ;how much to change delayTime, has values of 8,4,2,1
.equ delayTime, 0x25 ;How many instructions to skip between each motor pulse- inverse of speed
.equ dipCycleIndex, 0x26 ; How many strokes have we made?

.org 0x2000 ; put the code in Paulmon RAM

mov dipCycleIndex, #25 ; to make 25 dips
  
dip_stroke_loop:

    clr p1.1 ; make sure we're going down

    ; move slowly for 2 inches
    mov delayTime, #255 ;start at the slowest speed
    mov  r1,#50

    slow_travel_outer_loop:
    mov  r2, #255
        slow_travel_inner_loop:
            mov	r0, DelayTime
            slow_travel_waste_time:
            djnz	r0, slow_travel_waste_time
            setb	p1.0 ; step the motor
            clr	p1.0
        djnz  r2, slow_travel_inner_loop
    djnz  r1, slow_travel_outer_loop
  
    ;global initialization for acceleration
    mov delayTimeDelta, #16 ;there are 64 speed levels, grouped into 4 lineSegments of 16
    mov lineSegmentIndex, #4 ; we could just check for delayTimeDelta =  1 but dec from 4 to 0 is more obvious
    mov numSteps, #80  ;number of steps to move at a given speed
  
    ; this acceleration should take about 1 inch to complete
    ;for each of 4 iterations, cut delayTimeDelta in half
    lineSegmentLoop: ;controlled by decrementing lineSegmentIndex from 4 to 0
        mov	a, delayTimeDelta  ;for each segment, reduce delayTimeDelta by half to produce a log effect
        mov	b,#2
        div	ab
        mov	delayTimeDelta, a
        ; run the motor at the delayTime speed for numSteps distance within each of 16 iterations (4*16=64 speed levels)
        mov	sixteenSpeedsIndex, #16
      	sixteenSpeedsLoop:
            ;reduce delayTime by delayTimeDelta to make a faster speed
      	    mov   a, delayTime
        	subb  a, delayTimeDelta ; calculate a new speed
            mov   delayTime, a
      	    inc numSteps ;this determines how far the motor will rotate at this speed
      	    ;loop  "numSteps" pulses at this speed
      	    mov stepIndex, numSteps 
            travelNumStepsLoop:
                setb	p1.0
                clr	p1.0
                mov	r0, delayTime ; DelayTime is needed for next step, so make a copy
                wasteTimeLoop:
                djnz	r0, wasteTimeLoop   ;this is a tight NOP loop for DelayTime iterations
            djnz	stepIndex, travelNumStepsLoop
        djnz sixteenSpeedsIndex, sixteenSpeedsLoop
    djnz 	lineSegmentIndex, lineSegmentLoop

    travel:
    ;travel for 255 full steps
    mov  r1,#255 ; initalize the outer loop counter
    travel_pen_ultimate_loop:
        mov 	r2, #255
        travel_ultimate_loop:
            mov	r0, DelayTime
            travel_waste_time:
                djnz	r0, travel_waste_time
            setb  p1.0
            clr   p1.0
        djnz  r2, travel_ultimate_loop
    djnz  r1, travel_pen_ultimate_loop

    ; decelerate
    ; should take 1 inch, the same as the acceleration

    ;global re-initialization
    mov lineSegmentIndex, #5 ; we could just check for delayTimeDelta =  1 but dec from 4 to 0 is more obvious

    ;for each of 4 iterations, cut delayTimeDelta in half
    decel_lineSegmentLoop: ;controlled by decrementing lineSegmentIndex from 4 to 0
        mov  a, delayTimeDelta  ;for each segment, double delayTimeDelta to produce a log effect
        mov  b,#2
        mul	ab
        mov	delayTimeDelta, a
        ; run the motor at the delayTime speed for numSteps distance within each of 16 iterations (4*16=64 speed levels)
        mov  sixteenSpeedsIndex, #16
        decel_sixteenSpeedsLoop:
            ;increase delayTime by delayTimeDelta to make a slowerspeed
            mov a, delayTime
    	    add a, delayTimeDelta ; calculate a new speed
            mov delayTime, a
            ;set numSteps equal to the number of motor pulses delivered at this speed (used to be a constant , 20,or 40)
            dec numSteps ;this determines how far the motor will rotate at this speed
            mov stepIndex, numSteps 
            ;loop  "numSteps" pulses at this speed
            decel_travelNumStepsLoop:
                setb	p1.0
                clr	p1.0
                mov	r0, delayTime ; DelayTime is needed for next step, so make a copy
                decel_wasteTimeLoop:
                djnz	r0, decel_wasteTimeLoop   ;this is a tight NOP loop for DelayTime iterations
            djnz	stepIndex, decel_travelNumStepsLoop
        djnz sixteenSpeedsIndex, decel_sixteenSpeedsLoop
    djnz 	lineSegmentIndex, decel_lineSegmentLoop

    ; very short pause to give equipment a break. It should take about 6 milliseconds
    mov r1, #255
    mov r2, #255

    short_pause_outer_loop:
        short_pause_inner_loop:
        djnz  r2, short_pause_inner_loop
    djnz r1, short_pause_outer_loop

    ; let's go back up!
    setb    p1.1 ; make sure we're going up

    ; accelerate up

    ;global initialization for upwards acceleration
    ;  mov delayTimeDelta, #16 ;there are 64 speed levels, grouped into 4 lineSegments of 16
    mov lineSegmentIndex, #4 ; we could just check for delayTimeDelta =  1 but dec from 4 to 0 is more obvious
    ;  mov numSteps, #80  ;number of steps to move at a given speed

    ; this acceleration should take about 1 inch to complete
    ;for each of 4 iterations, cut delayTimeDelta in half
    up_lineSegmentLoop: ;controlled by decrementing lineSegmentIndex from 4 to 0
        mov	a, delayTimeDelta  ;for each segment, reduce delayTimeDelta by half to produce a log effect
        mov	b,#2
        div	ab
        mov	delayTimeDelta, a
        ; run the motor at the delayTime speed for numSteps distance within each of 16 iterations (4*16=64 speed levels)
        mov  sixteenSpeedsIndex, #16
        up_sixteenSpeedsLoop:
            ;reduce delayTime by delayTimeDelta to make a faster speed
            mov  a, delayTime
            subb a, delayTimeDelta ; calculate a new speed
            mov	delayTime, a
            ;set numSteps equal to the number of motor pulses delivered at this speed (used to be a constant , 20,or 40)
            inc numSteps ;this determines how far the motor will rotate at this speed
            mov stepIndex, numSteps 
            ;loop  "numSteps" pulses at this speed
            up_travelNumStepsLoop:
                setb	p1.0
                clr	p1.0
                mov	r0, delayTime ; DelayTime is needed for next step, so make a copy
                up_wasteTimeLoop:
                djnz  r0, up_wasteTimeLoop   ;this is a tight NOP loop for DelayTime iterations
            djnz  stepIndex, up_travelNumStepsLoop
        djnz sixteenSpeedsIndex, up_sixteenSpeedsLoop
    djnz 	lineSegmentIndex, up_lineSegmentLoop

    ; travel for 14 inches
    ; 200 steps/9 inches means that we want to go 311 steps
    ;Unfortunately, that won't fit in a byte.
    ; so, we have one loop that goes 24, another that goes 13.
    ; that gives us 312 steps!
    mov r0, #24
    mov r1, #13

    up_travel_outer1_loop:
        mov  r0, #24
        up_travel_outer2_loop:
            mov  r2, #255
            up_travel_full_step_loop:
                mov	r3, DelayTime
                up_travel_waste_time:
                djnz  r3, up_travel_waste_time
                setb p1.0
                clr  p1.0
            djnz  r2, up_travel_full_step_loop
        djnz  r0, up_travel_outer2_loop
    djnz  r1, up_travel_outer1_loop

    ; moving on to deceleration...

    ; decelerate
    ; should take 1 inch, the same as the acceleration

    ;global re-initialization
    mov lineSegmentIndex, #5 ; we could just check for delayTimeDelta =  1 but dec from 4 to 0 is more obvious

    ;for each of 4 iterations, cut delayTimeDelta in half
    up_decel_lineSegmentLoop: ;controlled by decrementing lineSegmentIndex from 4 to 0
    mov a, delayTimeDelta  ;for each segment, double delayTimeDelta to produce a log effect
    mov b,#2
    mul ab
    mov delayTimeDelta, a
    ; run the motor at the delayTime speed for numSteps distance within each of 16 iterations (4*16=64 speed levels)
    mov sixteenSpeedsIndex, #16
    up_decel_sixteenSpeedsLoop:
        ;increase delayTime by delayTimeDelta to make a slowerspeed
        mov a, delayTime
        add a, delayTimeDelta ; calculate a new speed
        mov delayTime, a
        ;set numSteps equal to the number of motor pulses delivered at this speed (used to be a constant , 20,or 40)
        dec numSteps ;this determines how far the motor will rotate at this speed
        ;loop  "numSteps" pulses at this speed
        mov stepIndex, numSteps 
        up_decel_travelNumStepsLoop:
            setb	p1.0
            clr	p1.0
            mov	r0, delayTime ; DelayTime is needed for next step, so make a copy
                up_decel_wasteTimeLoop:
                djnz	r0, up_decel_wasteTimeLoop   ;this is a tight NOP loop for DelayTime iterations
            djnz	stepIndex, up_decel_travelNumStepsLoop
        djnz sixteenSpeedsIndex, up_decel_sixteenSpeedsLoop
    djnz 	lineSegmentIndex, up_decel_lineSegmentLoop

    ; sit at the top for 3 seconds

    mov r0, #176
    mov r1, #255
    mov r2, #255
    mov r3, #9

long_pause_anti_anti_pen_ultimate_loop:
        long_pause_anti_pen_ultimate_loop:
            long_pause_pen_ultimate_loop:
                long_pause_ultimate_loop:
                djnz  r3, long_pause_ultimate_loop
            djnz r2, long_pause_pen_ultimate_loop
        djnz r1, long_pause_anti_pen_ultimate_loop
    djnz r0, long_pause_anti_anti_pen_ultimate_loop

    ; and we start over again
    djnz dipCycleIndex, jmp_to_dip_stroke_loop
    ljmp 0

   jmp_to_dip_stroke_loop: ; this little routine allows the outer djnz to jump further than -128.
        ljmp dip_stroke_loop