radix dec global__variables__bank0 equ 12 global__variables__bank1 equ 255 global__bit__variables__bank0 equ 40 global__bit__variables__bank1 equ 255 indf___register equ 0 pcl___register equ 2 c___byte equ 3 c___bit equ 0 z___byte equ 3 z___bit equ 2 rp0___byte equ 3 rp0___bit equ 5 rp1___byte equ 3 rp1___bit equ 6 irp___byte equ 3 irp___bit equ 7 trisa___register equ 0x85 trisb___register equ 0x86 fsr___register equ 4 pclath___register equ 10 org 0 start: nop nop nop goto skip___interrupt interrupt___vector: retfie skip___interrupt: ; Initialize TRIS registers movlw 233 ; Switch from register bank 0 to register bank 1 (which contains trisa___register) bsf rp0___byte,rp0___bit ; Register bank is now 1 movwf trisa___register clrf pclath___register ; Switch from register bank 1 to register bank 0 bcf rp0___byte,rp0___bit ; Register bank is now 0 goto main ; comment ############################################################################# ; comment {} ; comment {Copyright < c > 1999 - 2001 by Wayne C . Gramlich .} ; comment {All rights reserved .} ; comment {} ; comment {Permission to use , copy , modify , distribute , and sell this software} ; comment {for any purpose is hereby granted without fee provided that the above} ; comment {copyright notice and this permission are retained . The author makes} ; comment {no representations about the suitability of this software for any purpose .} ; comment {It is provided { as is } without express or implied warranty .} ; comment {} ; comment {This is a test harness for developing Robobricks . Basically it allows} ; comment {the user to type in an 8 - bit number in octal and send it to a RoboBrick .} ; comment {Any resulting data is read back and printed in octal . All communication} ; comment {occurs at 2400 baud . See} ; comment {} ; comment {http : / / web . gramlich . net / projects / robobricks / harness / index . html} ; comment {} ; comment {for more details .} ; comment {} ; comment ############################################################################# ; processor pic16f84 cp = off dp = off pwrte = disabled wdte = disabled fosc = xt ; 16377=0x3ff9 8199=0x2007 __config 16377 configuration___address equ 8199 ; constant clock_rate 4000000 clock_rate equ 4000000 ; constant instruction_rate clock_rate / 4 instruction_rate equ 1000000 ; constant baud_rate 2400 baud_rate equ 2400 ; constant instructions_per_bit instruction_rate / baud_rate instructions_per_bit equ 416 ; constant delays_per_bit 3 delays_per_bit equ 3 ; constant instructions_per_delay instructions_per_bit / delays_per_bit instructions_per_delay equ 138 ; constant delay_count instructions_per_delay / 6 delay_count equ 23 ; constant sp 32 sp equ 32 ; constant cr 13 cr equ 13 ; constant lf 10 lf equ 10 ; comment {Some bit definitions :} ; constant rx_slave_bit 0 rx_slave_bit equ 0 ; constant tx_slave_bit 1 tx_slave_bit equ 1 ; constant tx_master_bit 2 tx_master_bit equ 2 ; constant rx_master_bit 3 rx_master_bit equ 3 ; constant rx_slave_mask 1 << rx_slave_bit rx_slave_mask equ 1 ; constant tx_slave_mask 1 << tx_slave_bit tx_slave_mask equ 2 ; constant rx_master_mask 1 << rx_master_bit rx_master_mask equ 8 ; constant tx_master_mask 1 << tx_master_bit tx_master_mask equ 4 porta equ 5 tx_master_pin__byte equ 5 tx_master_pin__bit equ 2 rx_master_pin__byte equ 5 rx_master_pin__bit equ 3 tx_slave_pin__byte equ 5 tx_slave_pin__bit equ 1 rx_slave_pin__byte equ 5 rx_slave_pin__bit equ 0 heart__byte equ 5 heart__bit equ 4 portb equ 6 ; constant space 0xff space equ 255 ; constant buffer_size 5 buffer_size equ 5 ; string_constants Start string___fetch: movwf pcl___register ; hello = 0s'Harness-A' , cr , lf hello___string equ 0 hello: addwf pcl___register,f ; Length = 11 retlw 11 ; `Harness-A' retlw 72 retlw 97 retlw 114 retlw 110 retlw 101 retlw 115 retlw 115 retlw 45 retlw 65 ; cr retlw 13 ; lf retlw 10 ; string__constants End ; procedure main start main: main__variables__base equ global__variables__bank0+0 main__bytes__base equ main__variables__base+0 main__bits__base equ main__variables__base+10 main__total__bytes equ 10 main__100byte0 equ main__bytes__base+9 main__128byte0 equ main__bytes__base+9 ; arguments_none ; Read a byte . main__char equ main__bytes__base+0 main__number equ main__bytes__base+1 main__count equ main__bytes__base+2 main__index equ main__bytes__base+3 main__buffer equ main__bytes__base+4 ; Let all the capacitors charge up : ; `count_down index 250 ...' start movlw 250 movwf main__index main__74_loop: ; call delay {{ }} call delay decfsz main__index,f goto main__74_loop main__74_done: ; `count_down index 250 ...' end ; Print out a welcome message : ; index := 0 clrf main__index ; `while index < hello . size ...' start main__80while__continue: movlw 11 subwf main__index,w ; expression=` index < hello . size ' exp_delay=2 true_delay=9 false_delay=2 true_size=10 false_size=1 btfsc c___byte,c___bit goto main__80while__break ; char := hello ~~ {{ index }} incf main__index,w clrf pclath___register call hello movwf main__char ; call master_send {{ char , tx_master_mask }} movwf master_send__character movlw 4 call master_send ; index := index + 1 incf main__index,f goto main__80while__continue ; if exp=` index < hello . size ' false goto ; Other expression=` index < hello . size ' delay=-1 main__80while__break: ; `while index < hello . size ...' end ; Main loop ; number := 0 clrf main__number ; loop_forever ... start main__88loop__forever: ; Get a character : ; tx_slave_pin := 1 bsf tx_slave_pin__byte,tx_slave_pin__bit ; char := master_get {{ }} call master_get movf master_get__0return__byte,w movwf main__char ; Delay 2 / 3 ' s of bit make sure that get_byte is done . ; call delay {{ }} call delay ; call delay {{ }} call delay ; if { 0c'0' <= char && char < {{ 0c'9' + 1 }} } start movlw 48 subwf main__char,w ; expression=`0c'0' <= char' exp_delay=2 true_delay=-1 false_delay=1 true_size=103 false_size=1 btfss c___byte,c___bit goto and97__0false movlw 58 subwf main__char,w ; expression=`char < {{ 0c'9' + 1 }}' exp_delay=2 true_delay=9 false_delay=-1 true_size=11 false_size=87 btfsc c___byte,c___bit goto label97__1false label97__1true: and97__0true: ; if { 0c'0' <= char && char < {{ 0c'9' + 1 }} } body start ; Do a multiply by 8 then add in digit : ; call master_send {{ char }} movf main__char,w movwf master_send__character call master_send ; number := {{ number << 3 }} + char - 0c'0' rlf main__number,w movwf main__100byte0 rlf main__100byte0,f rlf main__100byte0,w andlw 248 addwf main__char,w addlw 208 movwf main__number ; if { 0c'0' <= char && char < {{ 0c'9' + 1 }} } body end goto label97__1end label97__1false: and97__0false: movlw 115 subwf main__char,w ; expression=`{ char = 0c's' }' exp_delay=2 true_delay=-1 false_delay=-1 true_size=8 false_size=74 btfss z___byte,z___bit goto label101__0false label101__0true: ; else_if { char = 0c's' } body start ; Send byte to brick , no wait : ; Echo command and send CRLF : ; call master_send {{ char }} movf main__char,w movwf master_send__character call master_send ; call master_crlf {{ }} call master_crlf ; Ship the byte down to the brick : ; call slave_send {{ number }} movf main__number,w movwf slave_send__data call slave_send ; number := 0 clrf main__number ; else_if { char = 0c's' } body end goto label101__0end label101__0false: movlw 119 subwf main__char,w ; expression=`{ char = 0c'w' }' exp_delay=2 true_delay=-1 false_delay=-1 true_size=37 false_size=32 btfss z___byte,z___bit goto label112__0false label112__0true: ; else_if { char = 0c'w' } body start ; Send byte to brick , wait for results : ; Echo command and send CRLF : ; call master_send {{ char }} movf main__char,w movwf master_send__character call master_send ; call master_crlf {{ }} call master_crlf ; Ship the byte down to the brick ... ; call slave_send {{ number }} movf main__number,w movwf slave_send__data call slave_send ; number := 0 clrf main__number ; call delay < > ; ... and wait for a response : ; index := 0 clrf main__index ; `while index < buffer_size ...' start main__127while__continue: movlw 5 subwf main__index,w ; expression=` index < buffer_size ' exp_delay=2 true_delay=9 false_delay=2 true_size=10 false_size=1 btfsc c___byte,c___bit goto main__127while__break ; buffer ~~ {{ index }} := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf main__128byte0 movlw LOW main__buffer addwf main__index,w movwf fsr___register movf main__128byte0,w movwf indf___register ; index := index + 1 incf main__index,f goto main__127while__continue ; if exp=` index < buffer_size ' false goto ; Other expression=` index < buffer_size ' delay=-1 main__127while__break: ; `while index < buffer_size ...' end ; index := 0 clrf main__index ; `while index < buffer_size ...' start main__133while__continue: movlw 5 subwf main__index,w ; expression=` index < buffer_size ' exp_delay=2 true_delay=7 false_delay=2 true_size=8 false_size=1 btfsc c___byte,c___bit goto main__133while__break ; call master_octal {{ buffer ~~ {{ index }} }} movlw LOW main__buffer addwf main__index,w movwf fsr___register movf indf___register,w movwf master_octal__number call master_octal ; index := index + 1 incf main__index,f goto main__133while__continue ; if exp=` index < buffer_size ' false goto ; Other expression=` index < buffer_size ' delay=-1 main__133while__break: ; `while index < buffer_size ...' end ; Terminate the output list ; call master_crlf {{ }} call master_crlf ; else_if { char = 0c'w' } body end goto label112__0end label112__0false: movlw 105 subwf main__char,w ; expression=`{ char = 0c'i' }' exp_delay=2 true_delay=-1 false_delay=-1 true_size=8 false_size=19 btfss z___byte,z___bit goto label140__0false label140__0true: ; else_if { char = 0c'i' } body start ; Interrogate the slave RoboBrick : ; Initialize the id index : ; call slave_send {{ 0xfd }} movlw 253 movwf slave_send__data call slave_send ; Get the first 8 bytes : ; call slave_id8 {{ }} call slave_id8 ; Get the next 8 bytes of random numbers : ; call slave_id8 {{ }} call slave_id8 ; Get the next 8 bytes of random numbers : ; call slave_id8 {{ }} call slave_id8 ; Get the slave brick name : ; call slave_id_string {{ }} call slave_id_string ; Get the vendor name : ; call slave_id_string {{ }} call slave_id_string ; else_if { char = 0c'i' } body end goto label140__0end label140__0false: movlw 252 subwf main__char,w ; expression=`{ char != 0xfc }' exp_delay=2 true_delay=-1 false_delay=0 true_size=15 false_size=0 btfsc z___byte,z___bit goto label160__0end ; else_if { char != 0xfc } body start ; Just echo back the current number : ; call master_send {{ 0c'<' }} movlw 60 movwf master_send__character call master_send ; call master_octal {{ char }} movf main__char,w movwf master_octal__number call master_octal ; call master_send {{ 0c'>' }} movlw 62 movwf master_send__character call master_send ; Send a carriage - return line - feed : ; call master_crlf {{ }} call master_crlf ; Output the character in octal : ; call master_octal {{ number }} movf main__number,w movwf master_octal__number call master_octal ; Send a carriage - return line - feed : ; call master_crlf {{ }} call master_crlf ; Reset number ; number := 0 clrf main__number ; else_if { char != 0xfc } body end label160__0end: ; if exp=` char != 0xfc ' empty false ; Other expression=`{ char != 0xfc }' delay=-1 ; if exp=` char = 0c'i' ' generic label140__0end: ; Other expression=`{ char = 0c'i' }' delay=-1 ; if exp=` char = 0c'w' ' generic label112__0end: ; Other expression=`{ char = 0c'w' }' delay=-1 ; if exp=` char = 0c's' ' generic label101__0end: ; Other expression=`{ char = 0c's' }' delay=-1 ; if exp=`char < {{ 0c'9' + 1 }}' generic label97__1end: ; Other expression=`char < {{ 0c'9' + 1 }}' delay=-1 ; if exp=`0c'0' <= char' false goto ; Other expression=`0c'0' <= char' delay=-1 and97__0end: ; if { 0c'0' <= char && char < {{ 0c'9' + 1 }} } end goto main__88loop__forever ; loop_forever ... end ; procedure main end ; procedure master_crlf start master_crlf: master_crlf__variables__base equ global__variables__bank0+10 master_crlf__bytes__base equ master_crlf__variables__base+0 master_crlf__bits__base equ master_crlf__variables__base+0 master_crlf__total__bytes equ 0 ; arguments_none ; This procedure will output a carriage - return line - feed ; to the master . ; call master_send {{ cr }} movlw 13 movwf master_send__character call master_send ; call master_send {{ lf }} movlw 10 movwf master_send__character call master_send ; procedure master_crlf end retlw 0 ; procedure master_get start master_get: master_get__variables__base equ global__variables__bank0+10 master_get__bytes__base equ master_get__variables__base+0 master_get__bits__base equ master_get__variables__base+1 master_get__total__bytes equ 1 ; arguments_none master_get__0return__byte equ master_get__bytes__base+0 ; This procedure will get the next byte or return 0xfc if ; no byte is forthcoming . ; return get_byte {{ rx_master_mask }} movlw 8 movwf get_byte__mask call get_byte movf get_byte__0return__byte,w movwf master_get__0return__byte retlw 0 ; procedure master_get end ; procedure master_send start master_send: master_send__variables__base equ global__variables__bank0+11 master_send__bytes__base equ master_send__variables__base+0 master_send__bits__base equ master_send__variables__base+1 master_send__total__bytes equ 1 master_send__character equ master_send__bytes__base+0 ; This procedure will output < character > to the master . ; call send_byte {{ character , tx_master_mask }} movf master_send__character,w movwf send_byte__char movlw 4 movwf send_byte__mask call send_byte ; procedure master_send end retlw 0 ; procedure master_octal start master_octal: master_octal__variables__base equ global__variables__bank0+12 master_octal__bytes__base equ master_octal__variables__base+0 master_octal__bits__base equ master_octal__variables__base+2 master_octal__total__bytes equ 2 master_octal__220byte0 equ master_octal__bytes__base+1 master_octal__219byte0 equ master_octal__bytes__base+1 master_octal__number equ master_octal__bytes__base+0 ; This procedure will output < number > in octal to the tx port . ; Output the character in octal : ; call master_send {{ {{ number >> 6 }} + 0c'0' }} swapf master_octal__number,w movwf master_octal__219byte0 rrf master_octal__219byte0,f rrf master_octal__219byte0,w andlw 3 addlw 48 movwf master_send__character call master_send ; call master_send {{ {{ {{ number >> 3 }} & 7 }} + 0c'0' }} rrf master_octal__number,w movwf master_octal__220byte0 rrf master_octal__220byte0,f rrf master_octal__220byte0,w andlw 7 addlw 48 movwf master_send__character call master_send ; call master_send {{ {{ number & 7 }} + 0c'0' }} movlw 7 andwf master_octal__number,w addlw 48 movwf master_send__character call master_send ; call master_send {{ sp }} movlw 32 movwf master_send__character call master_send ; procedure master_octal end retlw 0 ; procedure slave_get start slave_get: slave_get__variables__base equ global__variables__bank0+14 slave_get__bytes__base equ slave_get__variables__base+0 slave_get__bits__base equ slave_get__variables__base+1 slave_get__total__bytes equ 1 ; arguments_none slave_get__0return__byte equ slave_get__bytes__base+0 ; This procedure will get a byte from the slave or return 0xfc ; if no byte is forthcoming . ; return get_byte {{ rx_slave_mask }} movlw 1 movwf get_byte__mask call get_byte movf get_byte__0return__byte,w movwf slave_get__0return__byte retlw 0 ; procedure slave_get end ; procedure slave_id8 start slave_id8: slave_id8__variables__base equ global__variables__bank0+15 slave_id8__bytes__base equ slave_id8__variables__base+0 slave_id8__bits__base equ slave_id8__variables__base+1 slave_id8__total__bytes equ 1 ; arguments_none ; This procedure will print out the next 8 bytes of data from ; the slave RoboBrick id bytes . slave_id8__counter equ slave_id8__bytes__base+0 ; `count_down counter 8 ...' start movlw 8 movwf slave_id8__counter slave_id8__244_loop: ; call master_octal {{ slave_id_next {{ }} }} call slave_id_next movf slave_id_next__0return__byte,w movwf master_octal__number call master_octal decfsz slave_id8__counter,f goto slave_id8__244_loop slave_id8__244_done: ; `count_down counter 8 ...' end ; call master_crlf {{ }} call master_crlf ; procedure slave_id8 end retlw 0 ; procedure slave_id_next start slave_id_next: slave_id_next__variables__base equ global__variables__bank0+16 slave_id_next__bytes__base equ slave_id_next__variables__base+0 slave_id_next__bits__base equ slave_id_next__variables__base+1 slave_id_next__total__bytes equ 1 ; arguments_none slave_id_next__0return__byte equ slave_id_next__bytes__base+0 ; This procedure will return the next byte from the id bytes . ; call slave_send {{ 0xfc }} movlw 252 movwf slave_send__data call slave_send ; return slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf slave_id_next__0return__byte retlw 0 ; procedure slave_id_next end ; procedure slave_id_string start slave_id_string: slave_id_string__variables__base equ global__variables__bank0+17 slave_id_string__bytes__base equ slave_id_string__variables__base+0 slave_id_string__bits__base equ slave_id_string__variables__base+1 slave_id_string__total__bytes equ 1 ; arguments_none ; This procedure will return the string for the id bytes . slave_id_string__size equ slave_id_string__bytes__base+0 ; size := slave_id_next {{ }} call slave_id_next movf slave_id_next__0return__byte,w movwf slave_id_string__size ; call master_octal {{ size }} movwf master_octal__number call master_octal ; `count_down size size ...' start movf slave_id_string__size,w movwf slave_id_string__size slave_id_string__270_loop: ; call master_send {{ slave_id_next {{ }} }} call slave_id_next movf slave_id_next__0return__byte,w movwf master_send__character call master_send decfsz slave_id_string__size,f goto slave_id_string__270_loop slave_id_string__270_done: ; `count_down size size ...' end ; call master_crlf {{ }} call master_crlf ; procedure slave_id_string end retlw 0 ; procedure slave_send start slave_send: slave_send__variables__base equ global__variables__bank0+18 slave_send__bytes__base equ slave_send__variables__base+0 slave_send__bits__base equ slave_send__variables__base+1 slave_send__total__bytes equ 1 slave_send__data equ slave_send__bytes__base+0 ; This procedure will send one byte of < data > to the slave . ; call send_byte {{ data , tx_slave_mask }} movf slave_send__data,w movwf send_byte__char movlw 2 movwf send_byte__mask call send_byte ; procedure slave_send end retlw 0 ; procedure get_byte start get_byte: get_byte__variables__base equ global__variables__bank0+19 get_byte__bytes__base equ get_byte__variables__base+0 get_byte__bits__base equ get_byte__variables__base+4 get_byte__total__bytes equ 4 get_byte__mask equ get_byte__bytes__base+0 get_byte__0return__byte equ get_byte__bytes__base+1 ; Get an 8 - bit byte from < mask > bit of < porta > and return it . ; If no character shows up in a while 0xfc is returned . get_byte__count equ get_byte__bytes__base+2 get_byte__char equ get_byte__bytes__base+3 ; Wait until a start bit arrives : ; count := 0 clrf get_byte__count ; `while porta & mask != 0 ...' start get_byte__297while__continue: movf porta,w andwf get_byte__mask,w ; expression=` porta & mask != 0 ' exp_delay=2 true_delay=1 false_delay=2 true_size=9 false_size=1 btfsc z___byte,z___bit goto get_byte__297while__break ; count := count - 1 decf get_byte__count,f ; if { count = 0 } start movf get_byte__count,w ; expression=`{ count = 0 }' exp_delay=1 true_delay=3 false_delay=0 true_size=3 false_size=0 btfss z___byte,z___bit goto label299__0end ; if { count = 0 } body start ; return 0xfc movlw 252 movwf get_byte__0return__byte retlw 0 ; if { count = 0 } body end label299__0end: ; if exp=` count = 0 ' empty false ; Other expression=`{ count = 0 }' delay=-1 ; if { count = 0 } end ; call delay {{ }} call delay goto get_byte__297while__continue ; if exp=` porta & mask != 0 ' false goto ; Other expression=` porta & mask != 0 ' delay=-1 get_byte__297while__break: ; `while porta & mask != 0 ...' end ; Skip over the start bit : ; call delay {{ }} call delay ; call delay {{ }} call delay ; call delay {{ }} call delay ; Sample in the middle third of each data bit : ; char := 0 clrf get_byte__char ; `count_down count 8 ...' start movlw 8 movwf get_byte__count get_byte__312_loop: ; call delay {{ }} call delay ; char := char >> 1 bcf c___byte,c___bit rrf get_byte__char,f ; if { porta & mask != 0 } start movf porta,w andwf get_byte__mask,w ; expression=`{ porta & mask != 0 }' exp_delay=2 true_delay=1 false_delay=0 true_size=1 false_size=0 btfss z___byte,z___bit ; if { porta & mask != 0 } body start ; char := char | 0x80 ; char @ 7 := 1 ; Select char @ 7 get_byte__char__317select0 equ get_byte__char+0 get_byte__char__317select0__byte equ get_byte__char+0 get_byte__char__317select0__bit equ 7 bsf get_byte__char__317select0__byte,get_byte__char__317select0__bit ; if { porta & mask != 0 } body end ; if exp=` porta & mask != 0 ' false skip delay=4 ; Other expression=`{ porta & mask != 0 }' delay=4 ; if { porta & mask != 0 } end ; call delay {{ }} call delay ; call delay {{ }} call delay decfsz get_byte__count,f goto get_byte__312_loop get_byte__312_done: ; `count_down count 8 ...' end ; Skip over 1 / 3 of the stop bit : ; call delay {{ }} call delay ; return char movf get_byte__char,w movwf get_byte__0return__byte retlw 0 ; procedure get_byte end ; procedure send_byte start send_byte: send_byte__variables__base equ global__variables__bank0+23 send_byte__bytes__base equ send_byte__variables__base+0 send_byte__bits__base equ send_byte__variables__base+4 send_byte__total__bytes equ 4 send_byte__char equ send_byte__bytes__base+0 send_byte__mask equ send_byte__bytes__base+1 ; Send < char > to < mask > bit of < porta > . send_byte__count equ send_byte__bytes__base+2 send_byte__mark equ send_byte__bytes__base+3 ; Send the start bit : ; mark := mask ^ space movlw 255 xorwf send_byte__mask,w movwf send_byte__mark ; porta := mark movwf porta ; call delay {{ }} call delay ; call delay {{ }} call delay ; call delay {{ }} call delay ; Send the data : ; `count_down count 8 ...' start movlw 8 movwf send_byte__count send_byte__347_loop: ; if { char @ 0 } start ; Alias variable for select char @ 0 send_byte__char__348select0 equ send_byte__char+0 send_byte__char__348select0__byte equ send_byte__char+0 send_byte__char__348select0__bit equ 0 ; expression=`{ char @ 0 }' exp_delay=0 true_delay=1 false_delay=1 true_size=1 false_size=1 btfsc send_byte__char__348select0__byte,send_byte__char__348select0__bit ; if { char @ 0 } body start ; porta := space movlw 255 ; 1 instructions found for sharing btfss send_byte__char__348select0__byte,send_byte__char__348select0__bit ; else body start ; porta := mark movf send_byte__mark,w ; 1 instructions found for sharing ; if exp=` char @ 0 ' single true and false skip delay=4 ; Other expression=`{ char @ 0 }' delay=4 ; 1 shared instructions follow movwf porta ; if { char @ 0 } end ; char := char >> 1 bcf c___byte,c___bit rrf send_byte__char,f ; call delay {{ }} call delay ; call delay {{ }} call delay ; call delay {{ }} call delay decfsz send_byte__count,f goto send_byte__347_loop send_byte__347_done: ; `count_down count 8 ...' end ; Send the stop bit : ; porta := space movlw 255 movwf porta ; call delay {{ }} call delay ; call delay {{ }} call delay ; call delay {{ }} call delay ; procedure send_byte end retlw 0 ; procedure delay start ; optimize 0 delay: delay__variables__base equ global__variables__bank0+27 delay__bytes__base equ delay__variables__base+0 delay__bits__base equ delay__variables__base+1 delay__total__bytes equ 1 delay__366byte1 equ delay__bytes__base+0 ; arguments_none ; uniform_delay instructions_per_delay ; Uniform delay remaining = 134 Accumulated Delay = 0 ; Uniform delay remaining = 134 Accumulated Delay = 0 ; Delay 1 third of a bit : ; Uniform delay remaining = 134 Accumulated Delay = 0 ; Uniform delay remaining = 134 Accumulated Delay = 0 ; Soak up remaining 134 cycles ; Delay 134 cycles movlw 44 movwf delay__366byte1 delay__366delay0: decfsz delay__366byte1,f goto delay__366delay0 nop ; procedure delay end retlw 0 ; optimize 1 ; Register bank 0 used 28 bytes of 68 available bytes ; Register bank 1 used 0 bytes of 0 available bytes end