radix dec global__variables__bank0 equ 32 global__variables__bank1 equ 160 global__variables__bank2 equ 288 global__variables__bank3 equ 496 global__bit__variables__bank0 equ 98 global__bit__variables__bank1 equ 160 global__bit__variables__bank2 equ 288 global__bit__variables__bank3 equ 496 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 A/D system to allow digital I/O movlw 7 movwf 31 ; Switch from register bank 0 to register bank 1 (which contains 159) bsf rp0___byte,rp0___bit ; Register bank is now 1 clrf 159 ; Initialize TRIS registers movlw 235 movwf trisb___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 testing the InOut10 RoboBrick . See :} ; comment {} ; comment {http : / / web . gramlich . net / projects / robobricks / inout10 / index . html} ; comment {} ; comment {for more details .} ; comment {} ; comment ############################################################################# ; processor pic16f628 cp = off cpd = off lvp = off bowden = off mclre = on pwrte = off wdte = off fosc = xt ; 16169=0x3f29 8199=0x2007 __config 16169 configuration___address equ 8199 ; constant clock_rate 10000000 clock_rate equ 10000000 ; constant clock_ticks_per_instruction 4 clock_ticks_per_instruction equ 4 ; constant instructions_per_second clock_rate / clock_ticks_per_instruction instructions_per_second equ 2500000 ; constant baud_rate 2400 baud_rate equ 2400 ; constant instructions_per_bit clock_rate / {{ clock_ticks_per_instruction * baud_rate }} instructions_per_bit equ 1041 ; constant delays_per_bit 3 delays_per_bit equ 3 ; constant instructions_per_delay instructions_per_bit / delays_per_bit instructions_per_delay equ 347 ; constant extra_instructions_per_bit 12 extra_instructions_per_bit equ 12 ; constant extra_instructions_per_delay extra_instructions_per_bit / delays_per_bit extra_instructions_per_delay equ 4 ; constant delay_instructions instructions_per_delay - extra_instructions_per_delay delay_instructions equ 343 ; comment {The null pulse that comes back from a clock pulse command is supposed to be} ; comment {exactly 9 bits long . 9 bits at 2400 baud is 9 / 2400 = 3 . 75 mS . The number} ; comment {iterations through the loop is 3 . 75 mS / < number of instructions per iteration . >} ; constant nine_bits_instructions {{ clock_rate * 9 }} / {{ clock_ticks_per_instruction * baud_rate }} nine_bits_instructions equ 9375 ; constant instructions_per_iteration 7 instructions_per_iteration equ 7 ; constant iterations_for_nine_bits nine_bits_instructions / instructions_per_iteration iterations_for_nine_bits equ 1339 ; constant iterations_high iterations_for_nine_bits / 256 iterations_high equ 5 ; constant iterations_low iterations_for_nine_bits - {{ iterations_high * 256 }} iterations_low equ 59 ; comment {Some character constants :} ; 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 5 rx_slave_bit equ 5 ; constant tx_slave_bit 4 tx_slave_bit equ 4 ; constant rx_master_bit 1 rx_master_bit equ 1 ; constant tx_master_bit 2 tx_master_bit equ 2 ; constant rx_slave_mask 1 << rx_slave_bit rx_slave_mask equ 32 ; constant tx_slave_mask 1 << tx_slave_bit tx_slave_mask equ 16 ; constant rx_master_mask 1 << rx_master_bit rx_master_mask equ 2 ; constant tx_master_mask 1 << tx_master_bit tx_master_mask equ 4 ; comment {Some register definitions :} status equ 3 ; bind c status @ 0 c equ status+0 c__byte equ status+0 c__bit equ 0 ; bind z status @ 2 z equ status+0 z__byte equ status+0 z__bit equ 2 ; comment {Some port and pin definitions :} ; comment {port porta a unused none} portb equ 6 tx_master_pin__byte equ 6 tx_master_pin__bit equ 2 rx_master_pin__byte equ 6 rx_master_pin__bit equ 1 tx_slave_pin__byte equ 6 tx_slave_pin__bit equ 4 rx_slave_pin__byte equ 6 rx_slave_pin__bit equ 5 ; comment {Miscellaneous definitions :} ; constant space 0xff space equ 255 ; constant buffer_size 5 buffer_size equ 5 ; constant mask 0x1f mask equ 31 ; string_constants Start string___fetch: movwf pcl___register ; common_string = 0s'Common' common_string___string equ 0 common_string: addwf pcl___register,f ; Length = 6 retlw 6 ; `Common' retlw 67 retlw 111 retlw 109 retlw 109 retlw 111 retlw 110 ; patterns = 0 , 1 , 2 , 4 , 8 , 0x10 , 0x1f , 0xf , 0x17 , 0x1b , 0x1d , 0x1e , 0 patterns___string equ 8 patterns: addwf pcl___register,f ; Length = 13 retlw 13 ; 0 retlw 0 ; 1 retlw 1 ; 2 retlw 2 ; 4 retlw 4 ; 8 retlw 8 ; 0x10 retlw 16 ; 0x1f retlw 31 ; 0xf retlw 15 ; 0x17 retlw 23 ; 0x1b retlw 27 ; 0x1d retlw 29 ; 0x1e retlw 30 ; 0 retlw 0 ; done_string = 0s'Done' done_string___string equ 23 done_string: addwf pcl___register,f ; Length = 4 retlw 4 ; `Done' retlw 68 retlw 111 retlw 110 retlw 101 ; fail_string = 0s'Fail' fail_string___string equ 29 fail_string: addwf pcl___register,f ; Length = 4 retlw 4 ; `Fail' retlw 70 retlw 97 retlw 105 retlw 108 ; interrupt_string = 0s'Int' interrupt_string___string equ 35 interrupt_string: addwf pcl___register,f ; Length = 3 retlw 3 ; `Int' retlw 73 retlw 110 retlw 116 ; io_string = 0s'I/O' io_string___string equ 40 io_string: addwf pcl___register,f ; Length = 3 retlw 3 ; `I/O' retlw 73 retlw 47 retlw 79 ; hello_string = 0s'InOut10_Test' hello_string___string equ 45 hello_string: addwf pcl___register,f ; Length = 12 retlw 12 ; `InOut10_Test' retlw 73 retlw 110 retlw 79 retlw 117 retlw 116 retlw 49 retlw 48 retlw 95 retlw 84 retlw 101 retlw 115 retlw 116 ; test_string = 0s'Test' test_string___string equ 59 test_string: addwf pcl___register,f ; Length = 4 retlw 4 ; `Test' retlw 84 retlw 101 retlw 115 retlw 116 ; register_string = 0s'Reg' register_string___string equ 65 register_string: addwf pcl___register,f ; Length = 3 retlw 3 ; `Reg' retlw 82 retlw 101 retlw 103 ; 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__118byte0 equ main__bytes__base+9 main__146byte0 equ main__bytes__base+9 ; arguments_none ; Read a byte . main__buffer equ main__bytes__base+0 main__char equ main__bytes__base+5 main__count equ main__bytes__base+6 main__index equ main__bytes__base+7 main__number equ main__bytes__base+8 ; Print out a welcome message : ; call master_crlf {{ }} call master_crlf ; call master_string {{ hello_string }} movlw LOW hello_string+1 movwf master_string__message call master_string ; call master_crlf {{ }} call master_crlf ; Main loop ; number := 0 clrf main__number ; loop_forever ... start main__106loop__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=132 false_size=1 btfss c___byte,c___bit goto and115__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=116 btfsc c___byte,c___bit goto label115__1false label115__1true: and115__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__118byte0 rlf main__118byte0,f rlf main__118byte0,w andlw 248 addwf main__char,w addlw 208 movwf main__number ; if { 0c'0' <= char && char < {{ 0c'9' + 1 }} } body end goto label115__1end label115__1false: and115__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=103 btfss z___byte,z___bit goto label119__0false label119__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 label119__0end label119__0false: movlw 119 subwf main__char,w ; expression=`{ char = 0c'w' }' exp_delay=2 true_delay=-1 false_delay=-1 true_size=39 false_size=59 btfss z___byte,z___bit goto label130__0false label130__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__145while__continue: movlw 5 subwf main__index,w ; expression=` index < buffer_size ' exp_delay=2 true_delay=10 false_delay=2 true_size=11 false_size=1 btfsc c___byte,c___bit goto main__145while__break ; buffer ~~ {{ index }} := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf main__146byte0 movlw LOW main__buffer addwf main__index,w movwf fsr___register movf main__146byte0,w bcf irp___register,irp___bit movwf indf___register ; index := index + 1 incf main__index,f goto main__145while__continue ; if exp=` index < buffer_size ' false goto ; Other expression=` index < buffer_size ' delay=-1 main__145while__break: ; `while index < buffer_size ...' end ; index := 0 clrf main__index ; `while index < buffer_size ...' start main__151while__continue: movlw 5 subwf main__index,w ; expression=` index < buffer_size ' exp_delay=2 true_delay=8 false_delay=2 true_size=9 false_size=1 btfsc c___byte,c___bit goto main__151while__break ; call master_octal {{ buffer ~~ {{ index }} }} movlw LOW main__buffer addwf main__index,w movwf fsr___register bcf irp___register,irp___bit movf indf___register,w movwf master_octal__number call master_octal ; index := index + 1 incf main__index,f goto main__151while__continue ; if exp=` index < buffer_size ' false goto ; Other expression=` index < buffer_size ' delay=-1 main__151while__break: ; `while index < buffer_size ...' end ; Terminate the output list ; call master_crlf {{ }} call master_crlf ; else_if { char = 0c'w' } body end goto label130__0end label130__0false: movlw 105 subwf main__char,w ; expression=`{ char = 0c'i' }' exp_delay=2 true_delay=-1 false_delay=-1 true_size=12 false_size=42 btfss z___byte,z___bit goto label158__0false label158__0true: ; else_if { char = 0c'i' } body start ; Interrogate the slave RoboBrick : ; call master_send {{ char }} movf main__char,w movwf master_send__character call master_send ; call master_crlf {{ }} call master_crlf ; Initialize the id index : ; call slave_send {{ 0xfd }} movlw 253 movwf slave_send__data call slave_send ; Get the first 8 bytes : ; call common_test_id_bytes8 {{ }} call common_test_id_bytes8 ; Get the next 8 bytes of random numbers : ; call common_test_id_bytes8 {{ }} call common_test_id_bytes8 ; Get the next 8 bytes of random numbers : ; call common_test_id_bytes8 {{ }} call common_test_id_bytes8 ; Get the slave brick name : ; call common_test_id_string {{ }} call common_test_id_string ; Get the vendor name : ; call common_test_id_string {{ }} call common_test_id_string ; else_if { char = 0c'i' } body end goto label158__0end label158__0false: movlw 116 subwf main__char,w ; expression=`{ char = 0c't' }' exp_delay=2 true_delay=-1 false_delay=-1 true_size=5 false_size=32 btfss z___byte,z___bit goto label181__0false label181__0true: ; else_if { char = 0c't' } body start ; Do testing : ; call master_send {{ char }} movf main__char,w movwf master_send__character call master_send ; call master_crlf {{ }} call master_crlf ; call test {{ }} call test ; else_if { char = 0c't' } body end goto label181__0end label181__0false: movlw 99 subwf main__char,w ; expression=`{ char = 0c'c' }' exp_delay=2 true_delay=-1 false_delay=-1 true_size=8 false_size=19 btfss z___byte,z___bit goto label186__0false label186__0true: ; else_if { char = 0c'c' } body start ; call master_send {{ char }} movf main__char,w movwf master_send__character call master_send ; call master_crlf {{ }} call master_crlf ; call clock_adjust {{ number }} movf main__number,w movwf clock_adjust__adjust call clock_adjust ; number := 0 clrf main__number ; else_if { char = 0c'c' } body end goto label186__0end label186__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 label191__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 label191__0end: ; if exp=` char != 0xfc ' empty false ; Other expression=`{ char != 0xfc }' delay=-1 ; if exp=` char = 0c'c' ' generic label186__0end: ; Other expression=`{ char = 0c'c' }' delay=-1 ; if exp=` char = 0c't' ' generic label181__0end: ; Other expression=`{ char = 0c't' }' delay=-1 ; if exp=` char = 0c'i' ' generic label158__0end: ; Other expression=`{ char = 0c'i' }' delay=-1 ; if exp=` char = 0c'w' ' generic label130__0end: ; Other expression=`{ char = 0c'w' }' delay=-1 ; if exp=` char = 0c's' ' generic label119__0end: ; Other expression=`{ char = 0c's' }' delay=-1 ; if exp=`char < {{ 0c'9' + 1 }}' generic label115__1end: ; Other expression=`char < {{ 0c'9' + 1 }}' delay=-1 ; if exp=`0c'0' <= char' false goto ; Other expression=`0c'0' <= char' delay=-1 and115__0end: ; if { 0c'0' <= char && char < {{ 0c'9' + 1 }} } end goto main__106loop__forever ; loop_forever ... end ; procedure main end ; procedure clock_adjust start clock_adjust: clock_adjust__variables__base equ global__variables__bank0+10 clock_adjust__bytes__base equ clock_adjust__variables__base+0 clock_adjust__bits__base equ clock_adjust__variables__base+9 clock_adjust__total__bytes equ 9 clock_adjust__269byte0 equ clock_adjust__bytes__base+8 clock_adjust__283byte0 equ clock_adjust__bytes__base+8 clock_adjust__279byte0 equ clock_adjust__bytes__base+8 clock_adjust__227byte0 equ clock_adjust__bytes__base+8 clock_adjust__adjust equ clock_adjust__bytes__base+0 ; This procedure will adjust the clock to the slave . clock_adjust__command equ clock_adjust__bytes__base+1 clock_adjust__count equ clock_adjust__bytes__base+2 clock_adjust__error equ clock_adjust__bytes__base+3 clock_adjust__error_minimum equ clock_adjust__bytes__base+4 clock_adjust__high equ clock_adjust__bytes__base+5 clock_adjust__low equ clock_adjust__bytes__base+6 clock_adjust__target equ clock_adjust__bytes__base+7 ; target := iterations_low - adjust movlw 59 movwf clock_adjust__227byte0 movf clock_adjust__adjust,w subwf clock_adjust__227byte0,w movwf clock_adjust__target ; count := 2 movlw 2 movwf clock_adjust__count ; error := 0xff movlw 255 movwf clock_adjust__error ; error_minimum := 0xf0 movlw 240 movwf clock_adjust__error_minimum ; Print out the target : ; call master_send {{ 0c'T' }} movlw 84 movwf master_send__character call master_send ; call master_octal {{ iterations_high }} movlw 5 movwf master_octal__number call master_octal ; call master_octal {{ target }} movf clock_adjust__target,w movwf master_octal__number call master_octal ; call master_crlf {{ }} call master_crlf ; loop_forever ... start clock_adjust__238loop__forever: ; Print out the clock value : ; call master_send {{ 0c'C' }} movlw 67 movwf master_send__character call master_send ; call slave_send {{ 0xfa }} movlw 250 movwf slave_send__data call slave_send ; call master_octal {{ slave_get {{ }} }} call slave_get movf slave_get__0return__byte,w movwf master_octal__number call master_octal ; Ask for a timing byte : ; call slave_send {{ 0xfb }} movlw 251 movwf slave_send__data call slave_send ; low := 0 clrf clock_adjust__low ; high := 0 clrf clock_adjust__high ; `while rx_slave_pin ...' start clock_adjust__249while__continue: ; expression=`rx_slave_pin' exp_delay=0 true_delay=2 false_delay=2 true_size=1 false_size=1 btfsc rx_slave_pin__byte,rx_slave_pin__bit ; Do nothing : goto clock_adjust__249while__continue goto clock_adjust__249while__break ; if exp=`rx_slave_pin' true goto small true clock_adjust__249while__break: ; `while rx_slave_pin ...' end ; `while ! rx_slave_pin ...' start clock_adjust__252while__continue: ; expression=`rx_slave_pin' exp_delay=0 true_delay=2 false_delay=5 true_size=1 false_size=4 btfsc rx_slave_pin__byte,rx_slave_pin__bit goto clock_adjust__252while__break ; low := low + 1 incf clock_adjust__low,f ; if { z } start ; expression=`{ z }' exp_delay=0 true_delay=1 false_delay=0 true_size=1 false_size=0 btfsc z__byte,z__bit ; if { z } body start ; high := high + 1 incf clock_adjust__high,f ; if { z } body end ; if exp=`z' false skip delay=2 ; Other expression=`{ z }' delay=2 ; if { z } end goto clock_adjust__252while__continue ; if exp=`rx_slave_pin' true goto ; Other expression=`rx_slave_pin' delay=-1 clock_adjust__252while__break: ; `while ! rx_slave_pin ...' end ; Print out high and low : ; call master_send {{ 0c'H' }} movlw 72 movwf master_send__character call master_send ; call master_octal {{ high }} movf clock_adjust__high,w movwf master_octal__number call master_octal ; call master_send {{ 0c'L' }} movlw 76 movwf master_send__character call master_send ; call master_octal {{ low }} movf clock_adjust__low,w movwf master_octal__number call master_octal ; Now think about adjusting clock . ; if { high > iterations_high } start movlw 6 subwf clock_adjust__high,w ; expression=`{ high > iterations_high }' exp_delay=2 true_delay=7 false_delay=-1 true_size=7 false_size=36 btfsc c___byte,c___bit goto label266__0true label266__0false: movlw 5 subwf clock_adjust__high,w ; expression=`{ high < iterations_high }' exp_delay=2 true_delay=4 false_delay=-1 true_size=4 false_size=27 btfss c___byte,c___bit goto label270__0true label270__0false: ; else body start ; The high 8 - bits are equal : ; if { low > target } start movf clock_adjust__low,w subwf clock_adjust__target,w ; expression=`{ low > target }' exp_delay=2 true_delay=7 false_delay=-1 true_size=7 false_size=15 btfss c___byte,c___bit goto label276__0true label276__0false: movf clock_adjust__target,w subwf clock_adjust__low,w ; expression=`{ low < target }' exp_delay=2 true_delay=7 false_delay=3 true_size=7 false_size=3 btfss c___byte,c___bit goto label280__0true label280__0false: ; else body start ; Exact match ; we are done : ; command := 0 clrf clock_adjust__command ; error := 0 clrf clock_adjust__error ; error_minimum := 0 clrf clock_adjust__error_minimum ; else body end goto label280__0end label280__0true: ; else_if { low < target } body start ; Clock pulse is too short ; slave clock is too fast : ; command := 0xf8 movlw 248 movwf clock_adjust__command ; error := target - low movf clock_adjust__target,w movwf clock_adjust__283byte0 movf clock_adjust__low,w subwf clock_adjust__283byte0,w movwf clock_adjust__error ; else_if { low < target } body end ; if exp=` low < target ' generic label280__0end: ; Other expression=`{ low < target }' delay=-1 goto label276__0end label276__0true: ; if { low > target } body start ; Clock pulse is too long ; slave clock is too slow : ; command := 0xf9 movlw 249 movwf clock_adjust__command ; error := low - target movf clock_adjust__low,w movwf clock_adjust__279byte0 movf clock_adjust__target,w subwf clock_adjust__279byte0,w movwf clock_adjust__error ; if { low > target } body end ; if exp=` low > target ' generic label276__0end: ; Other expression=`{ low > target }' delay=-1 ; if { low > target } end ; else body end goto label270__0end label270__0true: ; else_if { high < iterations_high } body start ; Clock pulse is too short ; slave clock is too fast : ; command := 0xf8 movlw 248 movwf clock_adjust__command ; error := target movf clock_adjust__target,w movwf clock_adjust__error ; else_if { high < iterations_high } body end ; if exp=` high < iterations_high ' generic label270__0end: ; Other expression=`{ high < iterations_high }' delay=-1 goto label266__0end label266__0true: ; if { high > iterations_high } body start ; Clock pulse is too long ; slave clock is too slow : ; command := 0xf9 movlw 249 movwf clock_adjust__command ; error := 0xff - target movlw 255 movwf clock_adjust__269byte0 movf clock_adjust__target,w subwf clock_adjust__269byte0,w movwf clock_adjust__error ; if { high > iterations_high } body end ; if exp=` high > iterations_high ' generic label266__0end: ; Other expression=`{ high > iterations_high }' delay=-1 ; if { high > iterations_high } end ; Print out the error and error minimum : ; call master_send {{ 0c'E' }} movlw 69 movwf master_send__character call master_send ; call master_octal {{ error }} movf clock_adjust__error,w movwf master_octal__number call master_octal ; call master_send {{ 0c'M' }} movlw 77 movwf master_send__character call master_send ; call master_octal {{ error_minimum }} movf clock_adjust__error_minimum,w movwf master_octal__number call master_octal ; if { error = error_minimum } start movf clock_adjust__error,w subwf clock_adjust__error_minimum,w ; expression=`{ error = error_minimum }' exp_delay=2 true_delay=-1 false_delay=-1 true_size=2 false_size=14 btfss z___byte,z___bit goto label298__0false label298__0true: ; if { error = error_minimum } body start ; call master_crlf {{ }} call master_crlf ; return retlw 0 ; if { error = error_minimum } body end goto label298__0end label298__0false: movf clock_adjust__error_minimum,w subwf clock_adjust__error,w ; expression=`{ error < error_minimum }' exp_delay=2 true_delay=3 false_delay=-1 true_size=3 false_size=6 btfss c___byte,c___bit goto label301__0true label301__0false: ; else body start ; count := count - 1 decf clock_adjust__count,f ; if { z } start ; expression=`{ z }' exp_delay=0 true_delay=3 false_delay=0 true_size=3 false_size=0 btfss z__byte,z__bit goto label306__0end ; if { z } body start ; error_minimum := error_minimum + 1 incf clock_adjust__error_minimum,f ; count := 2 movlw 2 movwf clock_adjust__count ; if { z } body end label306__0end: ; if exp=`z' empty false ; Other expression=`{ z }' delay=-1 ; if { z } end ; else body end goto label301__0end label301__0true: ; else_if { error < error_minimum } body start ; error_minimum := error movf clock_adjust__error,w movwf clock_adjust__error_minimum ; error := error + 1 incf clock_adjust__error,f ; else_if { error < error_minimum } body end ; if exp=` error < error_minimum ' generic label301__0end: ; Other expression=`{ error < error_minimum }' delay=-1 ; if exp=` error = error_minimum ' generic label298__0end: ; Other expression=`{ error = error_minimum }' delay=-1 ; if { error = error_minimum } end ; Now adjust the clock : ; call slave_send {{ command }} movf clock_adjust__command,w movwf slave_send__data call slave_send ; call master_crlf {{ }} call master_crlf goto clock_adjust__238loop__forever ; loop_forever ... end ; procedure clock_adjust end ; procedure test start test: test__variables__base equ global__variables__bank0+19 test__bytes__base equ test__variables__base+0 test__bits__base equ test__variables__base+10 test__total__bytes equ 10 ; arguments_none ; This procedure will test the InOut10 RoboBrick . test__high equ test__bytes__base+0 test__index equ test__bytes__base+1 test__low equ test__bytes__base+2 test__low_high equ test__bytes__base+3 test__pattern equ test__bytes__base+4 test__pattern_index equ test__bytes__base+5 test__register_index equ test__bytes__base+6 test__read_command equ test__bytes__base+7 test__set_command equ test__bytes__base+8 test__temp equ test__bytes__base+9 ; This code assumes that the bit - wise pairs of the module ; have been tied together - - bit 0 to 1 , bit 2 to 3 , ... , ; bit 8 to 9 . ; Verify that the common commands are working : ; call common_test {{ }} call common_test ; Verify the common interrupt stuff : ; call interrupt_test {{ }} call interrupt_test ; Verify that the registers can all be read and written properly : ; call master_string {{ register_string }} movlw LOW register_string+1 movwf master_string__message call master_string ; call master_string {{ test_string }} movlw LOW test_string+1 movwf master_string__message call master_string ; call master_crlf {{ }} call master_crlf ; Force the outputs to all zeros so that when we teak ; the direction command below , the outputs are always ; driven to the same value . ; Verify that we can read and write the registers : ; register_index := 0 clrf test__register_index ; `while register_index < 8 ...' start test__357while__continue: movlw 8 subwf test__register_index,w ; expression=` register_index < 8 ' exp_delay=2 true_delay=1 false_delay=2 true_size=115 false_size=1 btfsc c___byte,c___bit goto test__357while__break ; switch { register_index } movlw HIGH switch__358block_start movwf pclath___register movf test__register_index,w ; case 0 ; case 1 ; case 3 ; case 4 ; case 5 ; case 6 ; case 7 switch__358block_start: addwf pcl___register,f goto switch__358block359 goto switch__358block364 goto switch__358end goto switch__358block369 goto switch__358block374 goto switch__358block379 goto switch__358block384 goto switch__358block389 switch__358block_end: ; switch_check 358 switch__358block_start switch__358block_end switch__358block359: ; Complement : ; read_command := 2 movlw 2 movwf test__read_command ; set_command := 0x12 movlw 18 movwf test__set_command goto switch__358end switch__358block364: ; Direction : ; read_command := 4 movlw 4 movwf test__read_command ; set_command := 0x14 movlw 20 movwf test__set_command goto switch__358end switch__358block369: ; Low : ; read_command := 8 movlw 8 movwf test__read_command ; set_command := 0x18 movlw 24 movwf test__set_command goto switch__358end switch__358block374: ; High : ; read_command := 0xa movlw 10 movwf test__read_command ; set_command := 0x1a movlw 26 movwf test__set_command goto switch__358end switch__358block379: ; Raising : ; read_command := 0xc movlw 12 movwf test__read_command ; set_command := 0x1c movlw 28 movwf test__set_command goto switch__358end switch__358block384: ; Falling : ; read_command := 0xe movlw 14 movwf test__read_command ; set_command := 0x1e movlw 30 movwf test__set_command goto switch__358end switch__358block389: ; Outputs : ; read_command := 0x10 movlw 16 movwf test__read_command ; set_command := 0xff movlw 255 movwf test__set_command switch__358end: ; Let ' s just do a reset to get the direction register set to all 1 ' s ; and the outputs to all zero ' s : ; call slave_send {{ 0x17 }} movlw 23 movwf slave_send__data call slave_send ; low_high := 0 clrf test__low_high ; `while low_high < 2 ...' start test__400while__continue: movlw 2 subwf test__low_high,w ; expression=` low_high < 2 ' exp_delay=2 true_delay=1 false_delay=2 true_size=58 false_size=1 btfsc c___byte,c___bit goto test__400while__break ; pattern_index := 0 clrf test__pattern_index ; `while pattern_index < patterns . size ...' start test__402while__continue: movlw 13 subwf test__pattern_index,w ; expression=` pattern_index < patterns . size ' exp_delay=2 true_delay=1 false_delay=2 true_size=51 false_size=1 btfsc c___byte,c___bit goto test__402while__break ; pattern := patterns ~~ {{ pattern_index }} incf test__pattern_index,w clrf pclath___register call patterns movwf test__pattern ; Write the pattern out : ; if { set_command = 0xff } start incf test__set_command,w ; expression=`{ set_command = 0xff }' exp_delay=1 true_delay=7 false_delay=1 true_size=6 false_size=5 btfsc z___byte,z___bit goto label406__0true label406__0false: ; else body start ; Otherwise just use set_command as is : ; call slave_send {{ set_command | low_high }} movf test__set_command,w iorwf test__low_high,w movwf slave_send__data call slave_send ; call slave_send {{ pattern }} movf test__pattern,w ; 2 instructions found for sharing goto label406__0end label406__0true: ; if { set_command = 0xff } body start ; Outputs are special : ; if { low_high = 0 } start movf test__low_high,w ; expression=`{ low_high = 0 }' exp_delay=1 true_delay=-1 false_delay=-1 true_size=1 false_size=1 btfsc z___byte,z___bit ; if { low_high = 0 } body start ; call slave_send {{ 0x20 | pattern }} movlw 32 ; 3 instructions found for sharing btfss z___byte,z___bit ; else body start ; call slave_send {{ 0x40 | pattern }} movlw 64 ; 3 instructions found for sharing ; if exp=` low_high = 0 ' single true and false skip delay=5 ; Other expression=`{ low_high = 0 }' delay=5 ; 3 shared instructions follow iorwf test__pattern,w ; 2 instructions found for sharing ; if exp=` set_command = 0xff ' generic label406__0end: ; Other expression=`{ set_command = 0xff }' delay=-1 ; 2 shared instructions follow movwf slave_send__data call slave_send ; if { set_command = 0xff } end ; Read the pattern back in : ; call slave_send {{ read_command | low_high }} movf test__read_command,w iorwf test__low_high,w movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__temp ; if { temp != pattern } start subwf test__pattern,w ; expression=`{ temp != pattern }' exp_delay=2 true_delay=7 false_delay=0 true_size=17 false_size=0 btfsc z___byte,z___bit goto label422__0end ; if { temp != pattern } body start ; call master_octal {{ register_index }} movf test__register_index,w movwf master_octal__number call master_octal ; call master_octal {{ low_high }} movf test__low_high,w movwf master_octal__number call master_octal ; call master_octal {{ pattern }} movf test__pattern,w movwf master_octal__number call master_octal ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_fail {{ register_string , 0x30 }} movlw LOW register_string+1 movwf master_fail__test_name movlw 48 movwf master_fail__test_number call master_fail ; if { temp != pattern } body end label422__0end: ; if exp=` temp != pattern ' empty false ; Other expression=`{ temp != pattern }' delay=-1 ; if { temp != pattern } end ; pattern_index := pattern_index + 1 incf test__pattern_index,f goto test__402while__continue ; if exp=` pattern_index < patterns . size ' false goto ; Other expression=` pattern_index < patterns . size ' delay=-1 test__402while__break: ; `while pattern_index < patterns . size ...' end ; low_high := low_high + 1 incf test__low_high,f goto test__400while__continue ; if exp=` low_high < 2 ' false goto ; Other expression=` low_high < 2 ' delay=-1 test__400while__break: ; `while low_high < 2 ...' end ; register_index := register_index + 1 incf test__register_index,f goto test__357while__continue ; if exp=` register_index < 8 ' false goto ; Other expression=` register_index < 8 ' delay=-1 test__357while__break: ; `while register_index < 8 ...' end ; Test out the inputs and outputs : ; call master_string {{ io_string }} movlw LOW io_string+1 movwf master_string__message call master_string ; call master_string {{ test_string }} movlw LOW test_string+1 movwf master_string__message call master_string ; call master_crlf {{ }} call master_crlf ; This code is really tedious : ; low_high := 0 clrf test__low_high ; `while low_high < 2 ...' start test__443while__continue: movlw 2 subwf test__low_high,w ; expression=` low_high < 2 ' exp_delay=2 true_delay=1 false_delay=2 true_size=231 false_size=1 btfsc c___byte,c___bit goto test__443while__break ; Set the direction bits into alternate mode : ; if { low_high = 0 } start movf test__low_high,w ; expression=`{ low_high = 0 }' exp_delay=1 true_delay=2 false_delay=2 true_size=10 false_size=10 btfss z___byte,z___bit goto label445__0false label445__0true: ; if { low_high = 0 } body start ; Pass 1 - - even pin outputs to odd pin inputs : ; call slave_send {{ 0x14 }} movlw 20 movwf slave_send__data call slave_send ; call slave_send {{ 0x15 }} movlw 21 movwf slave_send__data call slave_send ; call slave_send {{ 0x15 }} movlw 21 movwf slave_send__data call slave_send ; call slave_send {{ 0xa }} movlw 10 ; 2 instructions found for sharing goto label445__0end label445__0false: ; else body start ; Pass 2 - - odd pin outputs to even pin inputs : ; call slave_send {{ 0x14 }} movlw 20 movwf slave_send__data call slave_send ; call slave_send {{ 0xa }} movlw 10 movwf slave_send__data call slave_send ; call slave_send {{ 0x15 }} movlw 21 movwf slave_send__data call slave_send ; call slave_send {{ 0x15 }} movlw 21 ; 2 instructions found for sharing ; if exp=` low_high = 0 ' generic label445__0end: ; Other expression=`{ low_high = 0 }' delay=-1 ; 2 shared instructions follow movwf slave_send__data call slave_send ; if { low_high = 0 } end ; Send some patterns out : ; index := 0 clrf test__index ; `while index < 32 ...' start test__461while__continue: movlw 32 subwf test__index,w ; expression=` index < 32 ' exp_delay=2 true_delay=1 false_delay=2 true_size=198 false_size=1 btfsc c___byte,c___bit goto test__461while__break ; Spread bits abcde from < index > into aabbc and cddee ; in < high > and < low > : ; low := 0 clrf test__low ; high := 0 clrf test__high ; if { index @ 0 } start ; Alias variable for select index @ 0 test__index__466select0 equ test__index+0 test__index__466select0__byte equ test__index+0 test__index__466select0__bit equ 0 ; expression=`{ index @ 0 }' exp_delay=0 true_delay=2 false_delay=0 true_size=2 false_size=0 btfss test__index__466select0__byte,test__index__466select0__bit goto label466__1end ; if { index @ 0 } body start ; low @ 0 := 1 ; Select low @ 0 test__low__467select0 equ test__low+0 test__low__467select0__byte equ test__low+0 test__low__467select0__bit equ 0 bsf test__low__467select0__byte,test__low__467select0__bit ; low @ 1 := 1 ; Select low @ 1 test__low__468select0 equ test__low+0 test__low__468select0__byte equ test__low+0 test__low__468select0__bit equ 1 bsf test__low__468select0__byte,test__low__468select0__bit ; if { index @ 0 } body end label466__1end: ; if exp=` index @ 0 ' empty false ; Other expression=`{ index @ 0 }' delay=-1 ; if { index @ 0 } end ; if { index @ 1 } start ; Alias variable for select index @ 1 test__index__470select0 equ test__index+0 test__index__470select0__byte equ test__index+0 test__index__470select0__bit equ 1 ; expression=`{ index @ 1 }' exp_delay=0 true_delay=2 false_delay=0 true_size=2 false_size=0 btfss test__index__470select0__byte,test__index__470select0__bit goto label470__1end ; if { index @ 1 } body start ; low @ 2 := 1 ; Select low @ 2 test__low__471select0 equ test__low+0 test__low__471select0__byte equ test__low+0 test__low__471select0__bit equ 2 bsf test__low__471select0__byte,test__low__471select0__bit ; low @ 3 := 1 ; Select low @ 3 test__low__472select0 equ test__low+0 test__low__472select0__byte equ test__low+0 test__low__472select0__bit equ 3 bsf test__low__472select0__byte,test__low__472select0__bit ; if { index @ 1 } body end label470__1end: ; if exp=` index @ 1 ' empty false ; Other expression=`{ index @ 1 }' delay=-1 ; if { index @ 1 } end ; if { index @ 2 } start ; Alias variable for select index @ 2 test__index__474select0 equ test__index+0 test__index__474select0__byte equ test__index+0 test__index__474select0__bit equ 2 ; expression=`{ index @ 2 }' exp_delay=0 true_delay=2 false_delay=0 true_size=2 false_size=0 btfss test__index__474select0__byte,test__index__474select0__bit goto label474__1end ; if { index @ 2 } body start ; low @ 4 := 1 ; Select low @ 4 test__low__475select0 equ test__low+0 test__low__475select0__byte equ test__low+0 test__low__475select0__bit equ 4 bsf test__low__475select0__byte,test__low__475select0__bit ; high @ 0 := 1 ; Select high @ 0 test__high__476select0 equ test__high+0 test__high__476select0__byte equ test__high+0 test__high__476select0__bit equ 0 bsf test__high__476select0__byte,test__high__476select0__bit ; if { index @ 2 } body end label474__1end: ; if exp=` index @ 2 ' empty false ; Other expression=`{ index @ 2 }' delay=-1 ; if { index @ 2 } end ; if { index @ 3 } start ; Alias variable for select index @ 3 test__index__478select0 equ test__index+0 test__index__478select0__byte equ test__index+0 test__index__478select0__bit equ 3 ; expression=`{ index @ 3 }' exp_delay=0 true_delay=2 false_delay=0 true_size=2 false_size=0 btfss test__index__478select0__byte,test__index__478select0__bit goto label478__1end ; if { index @ 3 } body start ; high @ 1 := 1 ; Select high @ 1 test__high__479select0 equ test__high+0 test__high__479select0__byte equ test__high+0 test__high__479select0__bit equ 1 bsf test__high__479select0__byte,test__high__479select0__bit ; high @ 2 := 1 ; Select high @ 2 test__high__480select0 equ test__high+0 test__high__480select0__byte equ test__high+0 test__high__480select0__bit equ 2 bsf test__high__480select0__byte,test__high__480select0__bit ; if { index @ 3 } body end label478__1end: ; if exp=` index @ 3 ' empty false ; Other expression=`{ index @ 3 }' delay=-1 ; if { index @ 3 } end ; if { index @ 4 } start ; Alias variable for select index @ 4 test__index__482select0 equ test__index+0 test__index__482select0__byte equ test__index+0 test__index__482select0__bit equ 4 ; expression=`{ index @ 4 }' exp_delay=0 true_delay=2 false_delay=0 true_size=2 false_size=0 btfss test__index__482select0__byte,test__index__482select0__bit goto label482__1end ; if { index @ 4 } body start ; high @ 3 := 1 ; Select high @ 3 test__high__483select0 equ test__high+0 test__high__483select0__byte equ test__high+0 test__high__483select0__bit equ 3 bsf test__high__483select0__byte,test__high__483select0__bit ; high @ 4 := 1 ; Select high @ 4 test__high__484select0 equ test__high+0 test__high__484select0__byte equ test__high+0 test__high__484select0__bit equ 4 bsf test__high__484select0__byte,test__high__484select0__bit ; if { index @ 4 } body end label482__1end: ; if exp=` index @ 4 ' empty false ; Other expression=`{ index @ 4 }' delay=-1 ; if { index @ 4 } end ; Send the outputs : ; call slave_send {{ 0x20 | low }} movlw 32 iorwf test__low,w movwf slave_send__data call slave_send ; call slave_send {{ 0x40 | high }} movlw 64 iorwf test__high,w movwf slave_send__data call slave_send ; Now verify that the bits transfered across : ; Read Raw Low ; call slave_send {{ 6 }} movlw 6 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__temp ; if { temp != low } start subwf test__low,w ; expression=`{ temp != low }' exp_delay=2 true_delay=6 false_delay=0 true_size=14 false_size=0 btfsc z___byte,z___bit goto label495__0end ; if { temp != low } body start ; call master_octal {{ index }} movf test__index,w movwf master_octal__number call master_octal ; call master_octal {{ low }} movf test__low,w movwf master_octal__number call master_octal ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_fail {{ io_string , 0x31 }} movlw LOW io_string+1 movwf master_fail__test_name movlw 49 movwf master_fail__test_number call master_fail ; if { temp != low } body end label495__0end: ; if exp=` temp != low ' empty false ; Other expression=`{ temp != low }' delay=-1 ; if { temp != low } end ; Read Raw High ; call slave_send {{ 7 }} movlw 7 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__temp ; if { temp != high } start subwf test__high,w ; expression=`{ temp != high }' exp_delay=2 true_delay=6 false_delay=0 true_size=14 false_size=0 btfsc z___byte,z___bit goto label504__0end ; if { temp != high } body start ; call master_octal {{ index }} movf test__index,w movwf master_octal__number call master_octal ; call master_octal {{ high }} movf test__high,w movwf master_octal__number call master_octal ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_fail {{ io_string , 0x32 }} movlw LOW io_string+1 movwf master_fail__test_name movlw 50 movwf master_fail__test_number call master_fail ; if { temp != high } body end label504__0end: ; if exp=` temp != high ' empty false ; Other expression=`{ temp != high }' delay=-1 ; if { temp != high } end ; Set complement mask to all ones : ; call slave_send {{ 0x12 }} movlw 18 movwf slave_send__data call slave_send ; call slave_send {{ 0x1f }} movlw 31 movwf slave_send__data call slave_send ; call slave_send {{ 0x13 }} movlw 19 movwf slave_send__data call slave_send ; call slave_send {{ 0x1f }} movlw 31 movwf slave_send__data call slave_send ; Read Inputs Low ; call slave_send {{ 0 }} clrf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__temp ; if { temp ^ mask != low } start movlw 31 xorwf test__temp,w subwf test__low,w ; expression=`{ temp ^ mask != low }' exp_delay=3 true_delay=6 false_delay=0 true_size=14 false_size=0 btfsc z___byte,z___bit goto label520__0end ; if { temp ^ mask != low } body start ; call master_octal {{ index }} movf test__index,w movwf master_octal__number call master_octal ; call master_octal {{ low }} movf test__low,w movwf master_octal__number call master_octal ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_fail {{ io_string , 0x33 }} movlw LOW io_string+1 movwf master_fail__test_name movlw 51 movwf master_fail__test_number call master_fail ; if { temp ^ mask != low } body end label520__0end: ; if exp=` temp ^ mask != low ' empty false ; Other expression=`{ temp ^ mask != low }' delay=-1 ; if { temp ^ mask != low } end ; Read Inputs High ; call slave_send {{ 1 }} movlw 1 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__temp ; if { temp ^ mask != high } start movlw 31 xorwf test__temp,w subwf test__high,w ; expression=`{ temp ^ mask != high }' exp_delay=3 true_delay=6 false_delay=0 true_size=14 false_size=0 btfsc z___byte,z___bit goto label529__0end ; if { temp ^ mask != high } body start ; call master_octal {{ index }} movf test__index,w movwf master_octal__number call master_octal ; call master_octal {{ high }} movf test__high,w movwf master_octal__number call master_octal ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_fail {{ io_string , 0x34 }} movlw LOW io_string+1 movwf master_fail__test_name movlw 52 movwf master_fail__test_number call master_fail ; if { temp ^ mask != high } body end label529__0end: ; if exp=` temp ^ mask != high ' empty false ; Other expression=`{ temp ^ mask != high }' delay=-1 ; if { temp ^ mask != high } end ; Set complement mask to all zeros : ; call slave_send {{ 0x12 }} movlw 18 movwf slave_send__data call slave_send ; call slave_send {{ 0 }} clrf slave_send__data call slave_send ; call slave_send {{ 0x13 }} movlw 19 movwf slave_send__data call slave_send ; call slave_send {{ 0 }} clrf slave_send__data call slave_send ; Read Inputs Low ; call slave_send {{ 0 }} clrf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__temp ; if { temp != low } start subwf test__low,w ; expression=`{ temp != low }' exp_delay=2 true_delay=6 false_delay=0 true_size=14 false_size=0 btfsc z___byte,z___bit goto label545__0end ; if { temp != low } body start ; call master_octal {{ index }} movf test__index,w movwf master_octal__number call master_octal ; call master_octal {{ low }} movf test__low,w movwf master_octal__number call master_octal ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_fail {{ io_string , 0x35 }} movlw LOW io_string+1 movwf master_fail__test_name movlw 53 movwf master_fail__test_number call master_fail ; if { temp != low } body end label545__0end: ; if exp=` temp != low ' empty false ; Other expression=`{ temp != low }' delay=-1 ; if { temp != low } end ; Read Inputs High ; call slave_send {{ 1 }} movlw 1 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__temp ; if { temp != high } start subwf test__high,w ; expression=`{ temp != high }' exp_delay=2 true_delay=6 false_delay=0 true_size=14 false_size=0 btfsc z___byte,z___bit goto label554__0end ; if { temp != high } body start ; call master_octal {{ index }} movf test__index,w movwf master_octal__number call master_octal ; call master_octal {{ high }} movf test__high,w movwf master_octal__number call master_octal ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_fail {{ io_string , 0x36 }} movlw LOW io_string+1 movwf master_fail__test_name movlw 54 movwf master_fail__test_number call master_fail ; if { temp != high } body end label554__0end: ; if exp=` temp != high ' empty false ; Other expression=`{ temp != high }' delay=-1 ; if { temp != high } end ; index := index + 1 incf test__index,f goto test__461while__continue ; if exp=` index < 32 ' false goto ; Other expression=` index < 32 ' delay=-1 test__461while__break: ; `while index < 32 ...' end ; low_high := low_high + 1 incf test__low_high,f goto test__443while__continue ; if exp=` low_high < 2 ' false goto ; Other expression=` low_high < 2 ' delay=-1 test__443while__break: ; `while low_high < 2 ...' end ; Now test the interrupt stuff : ; call master_string {{ interrupt_string }} movlw LOW interrupt_string+1 movwf master_string__message call master_string ; call master_string {{ test_string }} movlw LOW test_string+1 movwf master_string__message call master_string ; call master_crlf {{ }} call master_crlf ; Set even pin outputs to odd pin inputs : ; call slave_send {{ 0x14 }} movlw 20 movwf slave_send__data call slave_send ; call slave_send {{ 0x15 }} movlw 21 movwf slave_send__data call slave_send ; call slave_send {{ 0x15 }} movlw 21 movwf slave_send__data call slave_send ; call slave_send {{ 0xa }} movlw 10 movwf slave_send__data call slave_send ; Low test : ; call test_interrupt {{ 0x18 , 0x20 , mask , 0x40 }} movlw 24 movwf test_interrupt__mask_set movlw 32 movwf test_interrupt__output_set movlw 31 movwf test_interrupt__pattern movlw 64 movwf test_interrupt__error call test_interrupt ; call test_interrupt {{ 0x19 , 0x40 , mask , 0x42 }} movlw 25 movwf test_interrupt__mask_set movlw 64 movwf test_interrupt__output_set movlw 31 movwf test_interrupt__pattern movlw 66 movwf test_interrupt__error call test_interrupt ; High test : ; call test_interrupt {{ 0x1a , 0x20 , 0 , 0x44 }} movlw 26 movwf test_interrupt__mask_set movlw 32 movwf test_interrupt__output_set clrf test_interrupt__pattern movlw 68 movwf test_interrupt__error call test_interrupt ; call test_interrupt {{ 0x1b , 0x40 , 0 , 0x46 }} movlw 27 movwf test_interrupt__mask_set movlw 64 movwf test_interrupt__output_set clrf test_interrupt__pattern movlw 70 movwf test_interrupt__error call test_interrupt ; Raising test : ; call test_interrupt {{ 0x1c , 0x20 , 0 , 0x48 }} movlw 28 movwf test_interrupt__mask_set movlw 32 movwf test_interrupt__output_set clrf test_interrupt__pattern movlw 72 movwf test_interrupt__error call test_interrupt ; call test_interrupt {{ 0x1d , 0x40 , 0 , 0x4a }} movlw 29 movwf test_interrupt__mask_set movlw 64 movwf test_interrupt__output_set clrf test_interrupt__pattern movlw 74 movwf test_interrupt__error call test_interrupt ; Falling test : ; call test_interrupt {{ 0x1e , 0x20 , mask , 0x4c }} movlw 30 movwf test_interrupt__mask_set movlw 32 movwf test_interrupt__output_set movlw 31 movwf test_interrupt__pattern movlw 76 movwf test_interrupt__error call test_interrupt ; call test_interrupt {{ 0x1f , 0x40 , mask , 0x4e }} movlw 31 movwf test_interrupt__mask_set movlw 64 movwf test_interrupt__output_set movlw 31 movwf test_interrupt__pattern movlw 78 movwf test_interrupt__error call test_interrupt ; Reset everything : ; call slave_send {{ 0x17 }} movlw 23 movwf slave_send__data call slave_send ; Announce that we are done : ; call master_string {{ done_string }} movlw LOW done_string+1 movwf master_string__message call master_string ; call master_crlf {{ }} call master_crlf ; procedure test end retlw 0 ; procedure test_interrupt start test_interrupt: test_interrupt__variables__base equ global__variables__bank0+29 test_interrupt__bytes__base equ test_interrupt__variables__base+0 test_interrupt__bits__base equ test_interrupt__variables__base+5 test_interrupt__total__bytes equ 5 test_interrupt__mask_set equ test_interrupt__bytes__base+0 test_interrupt__output_set equ test_interrupt__bytes__base+1 test_interrupt__pattern equ test_interrupt__bytes__base+2 test_interrupt__error equ test_interrupt__bytes__base+3 ; This procedure will test interrupts . test_interrupt__temp equ test_interrupt__bytes__base+4 ; Set outputs to pattern : ; call slave_send {{ output_set | pattern }} movf test_interrupt__output_set,w iorwf test_interrupt__pattern,w movwf slave_send__data call slave_send ; Set the mask to all one ' s : ; call slave_send {{ mask_set }} movf test_interrupt__mask_set,w movwf slave_send__data call slave_send ; call slave_send {{ mask }} movlw 31 movwf slave_send__data call slave_send ; Verify that pending is not set : ; call slave_send {{ 0xef }} movlw 239 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test_interrupt__temp ; if { temp != 0 } start ; expression=`{ temp != 0 }' exp_delay=1 true_delay=4 false_delay=0 true_size=8 false_size=0 btfsc z___byte,z___bit goto label619__0end ; if { temp != 0 } body start ; call master_octal {{ temp }} movf test_interrupt__temp,w movwf master_octal__number call master_octal ; call master_fail {{ interrupt_string , error }} movlw LOW interrupt_string+1 movwf master_fail__test_name movf test_interrupt__error,w movwf master_fail__test_number call master_fail ; if { temp != 0 } body end label619__0end: ; if exp=` temp != 0 ' empty false ; Other expression=`{ temp != 0 }' delay=-1 ; if { temp != 0 } end ; Now complement the outputs : ; call slave_send {{ output_set | {{ pattern ^ mask }} }} movlw 31 xorwf test_interrupt__pattern,w iorwf test_interrupt__output_set,w movwf slave_send__data call slave_send ; Verify that pending is set : ; call slave_send {{ 0xef }} movlw 239 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test_interrupt__temp ; if { temp != 1 } start decf test_interrupt__temp,w ; expression=`{ temp != 1 }' exp_delay=1 true_delay=4 false_delay=0 true_size=8 false_size=0 btfsc z___byte,z___bit goto label630__0end ; if { temp != 1 } body start ; call master_octal {{ temp }} movf test_interrupt__temp,w movwf master_octal__number call master_octal ; call master_fail {{ interrupt_string , error + 1 }} movlw LOW interrupt_string+1 movwf master_fail__test_name incf test_interrupt__error,w movwf master_fail__test_number call master_fail ; if { temp != 1 } body end label630__0end: ; if exp=` temp != 1 ' empty false ; Other expression=`{ temp != 1 }' delay=-1 ; if { temp != 1 } end ; Now clear the interrupt mask : ; call slave_send {{ mask_set }} movf test_interrupt__mask_set,w movwf slave_send__data call slave_send ; call slave_send {{ 0 }} clrf slave_send__data call slave_send ; Now clear the pending bit : ; call slave_send {{ 0xf0 }} movlw 240 movwf slave_send__data call slave_send ; procedure test_interrupt end retlw 0 ; comment {The procedures below are used to test the common shared commands :} ; procedure common_test start common_test: common_test__variables__base equ global__variables__bank0+34 common_test__bytes__base equ common_test__variables__base+0 common_test__bits__base equ common_test__variables__base+2 common_test__total__bytes equ 2 common_test__688byte0 equ common_test__bytes__base+1 ; arguments_none ; This procedure will verify that the common shared commands work . common_test__actual equ common_test__bytes__base+0 ; Print the ID information : ; ID reset : ; call slave_send {{ 0xfd }} movlw 253 movwf slave_send__data call slave_send ; Read the fixed bytes : ; call common_test_id_match {{ 1 , 0xc0 }} movlw 1 movwf common_test_id_match__desired movlw 192 movwf common_test_id_match__test_number call common_test_id_match ; call common_test_id_match {{ 0 , 0xc1 }} clrf common_test_id_match__desired movlw 193 movwf common_test_id_match__test_number call common_test_id_match ; call common_test_id_match {{ 13 , 0xc2 }} movlw 13 movwf common_test_id_match__desired movlw 194 movwf common_test_id_match__test_number call common_test_id_match ; call common_test_id_match {{ 0 , 0xc3 }} clrf common_test_id_match__desired movlw 195 movwf common_test_id_match__test_number call common_test_id_match ; call common_test_id_match {{ 0 , 0xc4 }} clrf common_test_id_match__desired movlw 196 movwf common_test_id_match__test_number call common_test_id_match ; call common_test_id_match {{ 0 , 0xc5 }} clrf common_test_id_match__desired movlw 197 movwf common_test_id_match__test_number call common_test_id_match ; call common_test_id_match {{ 0 , 0xc6 }} clrf common_test_id_match__desired movlw 198 movwf common_test_id_match__test_number call common_test_id_match ; call common_test_id_match {{ 0 , 0xc7 }} clrf common_test_id_match__desired movlw 199 movwf common_test_id_match__test_number call common_test_id_match ; call master_crlf {{ }} call master_crlf ; call common_test_id_bytes8 {{ }} call common_test_id_bytes8 ; call common_test_id_bytes8 {{ }} call common_test_id_bytes8 ; Read the brick name : ; call common_test_id_string {{ }} call common_test_id_string ; Read the vendor name : ; call common_test_id_string {{ }} call common_test_id_string ; Verfify that we don ' t read off the end of the id and crash : ; call common_test_id_next {{ }} call common_test_id_next movf common_test_id_next__0return__byte,w ; Reset id : ; call slave_send {{ 0xfd }} movlw 253 movwf slave_send__data call slave_send ; Verify that we are still alive : ; call common_test_id_match {{ 1 , 0xc8 }} movlw 1 movwf common_test_id_match__desired movlw 200 movwf common_test_id_match__test_number call common_test_id_match ; Read glitch : ; Clear glitch register : ; call slave_send {{ 0xfe }} movlw 254 movwf slave_send__data call slave_send ; actual := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf common_test__actual ; Send a couple of glitches : ; call slave_send {{ 0xff }} movlw 255 movwf slave_send__data call slave_send ; call slave_send {{ 0xff }} movlw 255 movwf slave_send__data call slave_send ; Read the glitch register : ; call slave_send {{ 0xfe }} movlw 254 movwf slave_send__data call slave_send ; if { slave_get {{ }} != 2 } start call slave_get movf slave_get__0return__byte,w movwf common_test__688byte0 movlw 2 subwf common_test__688byte0,w ; expression=`{ slave_get {{ }} != 2 }' exp_delay=3 true_delay=3 false_delay=0 true_size=5 false_size=0 btfsc z___byte,z___bit goto label688__1end ; if { slave_get {{ }} != 2 } body start ; call master_fail {{ common_string , 0xc9 }} movlw LOW common_string+1 movwf master_fail__test_name movlw 201 movwf master_fail__test_number call master_fail ; if { slave_get {{ }} != 2 } body end label688__1end: ; if exp=` slave_get ## {{ }} != 2 ' empty false ; Other expression=`{ slave_get {{ }} != 2 }' delay=-1 ; if { slave_get {{ }} != 2 } end ; Do a clock pulse : ; call slave_send {{ 0xfb }} movlw 251 movwf slave_send__data call slave_send ; if { slave_get {{ }} != 0 } start call slave_get movf slave_get__0return__byte,w ; expression=`{ slave_get {{ }} != 0 }' exp_delay=0 true_delay=3 false_delay=0 true_size=5 false_size=0 btfsc z___byte,z___bit goto label694__0end ; if { slave_get {{ }} != 0 } body start ; call master_fail {{ common_string , 0xca }} movlw LOW common_string+1 movwf master_fail__test_name movlw 202 movwf master_fail__test_number call master_fail ; if { slave_get {{ }} != 0 } body end label694__0end: ; if exp=` slave_get ## {{ }} != 0 ' empty false ; Other expression=`{ slave_get {{ }} != 0 }' delay=-1 ; if { slave_get {{ }} != 0 } end ; Read clock : ; call slave_send {{ 0xfa }} movlw 250 movwf slave_send__data call slave_send ; actual := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf common_test__actual ; Increment : ; call slave_send {{ 0xf9 }} movlw 249 movwf slave_send__data call slave_send ; Decrement : ; call slave_send {{ 0xf8 }} movlw 248 movwf slave_send__data call slave_send ; Read clock again : ; call slave_send {{ 0xfa }} movlw 250 movwf slave_send__data call slave_send ; if { actual != slave_get {{ }} } start call slave_get movf slave_get__0return__byte,w subwf common_test__actual,w ; expression=`{ actual != slave_get {{ }} }' exp_delay=1 true_delay=3 false_delay=0 true_size=5 false_size=0 btfsc z___byte,z___bit goto label706__0end ; if { actual != slave_get {{ }} } body start ; call master_fail {{ common_string , 0xcb }} movlw LOW common_string+1 movwf master_fail__test_name movlw 203 movwf master_fail__test_number call master_fail ; if { actual != slave_get {{ }} } body end label706__0end: ; if exp=` actual != slave_get ## {{ }} ' empty false ; Other expression=`{ actual != slave_get {{ }} }' delay=-1 ; if { actual != slave_get {{ }} } end ; procedure common_test end retlw 0 ; procedure common_test_id_match start common_test_id_match: common_test_id_match__variables__base equ global__variables__bank0+36 common_test_id_match__bytes__base equ common_test_id_match__variables__base+0 common_test_id_match__bits__base equ common_test_id_match__variables__base+2 common_test_id_match__total__bytes equ 2 common_test_id_match__desired equ common_test_id_match__bytes__base+0 common_test_id_match__test_number equ common_test_id_match__bytes__base+1 ; This procedure will verify that the next byte in the id is < desired > . ; if { desired != common_test_id_next {{ }} } start call common_test_id_next movf common_test_id_next__0return__byte,w subwf common_test_id_match__desired,w ; expression=`{ desired != common_test_id_next {{ }} }' exp_delay=1 true_delay=3 false_delay=0 true_size=5 false_size=0 btfsc z___byte,z___bit goto label718__0end ; if { desired != common_test_id_next {{ }} } body start ; call master_fail {{ common_string , test_number }} movlw LOW common_string+1 movwf master_fail__test_name movf common_test_id_match__test_number,w movwf master_fail__test_number call master_fail ; if { desired != common_test_id_next {{ }} } body end label718__0end: ; if exp=` desired != common_test_id_next ## {{ }} ' empty false ; Other expression=`{ desired != common_test_id_next {{ }} }' delay=-1 ; if { desired != common_test_id_next {{ }} } end ; procedure common_test_id_match end retlw 0 ; procedure common_test_id_bytes8 start common_test_id_bytes8: common_test_id_bytes8__variables__base equ global__variables__bank0+38 common_test_id_bytes8__bytes__base equ common_test_id_bytes8__variables__base+0 common_test_id_bytes8__bits__base equ common_test_id_bytes8__variables__base+1 common_test_id_bytes8__total__bytes equ 1 ; arguments_none ; This procedure will print out the next 8 bytes of the id in octal . common_test_id_bytes8__count equ common_test_id_bytes8__bytes__base+0 ; `count_down count 8 ...' start movlw 8 movwf common_test_id_bytes8__count common_test_id_bytes8__731_loop: ; call master_octal {{ common_test_id_next {{ }} }} call common_test_id_next movf common_test_id_next__0return__byte,w movwf master_octal__number call master_octal decfsz common_test_id_bytes8__count,f goto common_test_id_bytes8__731_loop common_test_id_bytes8__731_done: ; `count_down count 8 ...' end ; call master_crlf {{ }} call master_crlf ; procedure common_test_id_bytes8 end retlw 0 ; procedure common_test_id_string start common_test_id_string: common_test_id_string__variables__base equ global__variables__bank0+39 common_test_id_string__bytes__base equ common_test_id_string__variables__base+0 common_test_id_string__bits__base equ common_test_id_string__variables__base+1 common_test_id_string__total__bytes equ 1 ; arguments_none ; This procedure will print out the next id string . common_test_id_string__count equ common_test_id_string__bytes__base+0 ; `count_down count common_test_id_next ## {{ }} ...' start call common_test_id_next movf common_test_id_next__0return__byte,w movwf common_test_id_string__count common_test_id_string__745_loop: ; call master_send {{ common_test_id_next {{ }} }} call common_test_id_next movf common_test_id_next__0return__byte,w movwf master_send__character call master_send decfsz common_test_id_string__count,f goto common_test_id_string__745_loop common_test_id_string__745_done: ; `count_down count common_test_id_next ## {{ }} ...' end ; call master_crlf {{ }} call master_crlf ; procedure common_test_id_string end retlw 0 ; procedure common_test_id_next start common_test_id_next: common_test_id_next__variables__base equ global__variables__bank0+40 common_test_id_next__bytes__base equ common_test_id_next__variables__base+0 common_test_id_next__bits__base equ common_test_id_next__variables__base+1 common_test_id_next__total__bytes equ 1 ; arguments_none common_test_id_next__0return__byte equ common_test_id_next__bytes__base+0 ; This procedure returns the next byte from the identification string . ; 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 common_test_id_next__0return__byte retlw 0 ; procedure common_test_id_next end ; comment {The procedures below are used to test the shared interrupt commands :} ; procedure interrupt_test start interrupt_test: interrupt_test__variables__base equ global__variables__bank0+41 interrupt_test__bytes__base equ interrupt_test__variables__base+0 interrupt_test__bits__base equ interrupt_test__variables__base+1 interrupt_test__total__bytes equ 1 ; arguments_none ; This procedure tests the common shared interrupt commands . interrupt_test__counter equ interrupt_test__bytes__base+0 ; Clear interrupt bits : ; call slave_send {{ 0xf0 }} movlw 240 movwf slave_send__data call slave_send ; call interrupt_read {{ 0 , 0xd0 }} clrf interrupt_read__desired movlw 208 movwf interrupt_read__test_number call interrupt_read ; Set / clear interrupt pending bit only : ; call slave_send {{ 0xf5 }} movlw 245 movwf slave_send__data call slave_send ; call interrupt_read {{ 1 , 0xd1 }} movlw 1 movwf interrupt_read__desired movlw 209 movwf interrupt_read__test_number call interrupt_read ; call slave_send {{ 0xf4 }} movlw 244 movwf slave_send__data call slave_send ; call interrupt_read {{ 0 , 0xd2 }} clrf interrupt_read__desired movlw 210 movwf interrupt_read__test_number call interrupt_read ; call slave_send {{ 0xf1 }} movlw 241 movwf slave_send__data call slave_send ; call interrupt_read {{ 1 , 0xd3 }} movlw 1 movwf interrupt_read__desired movlw 211 movwf interrupt_read__test_number call interrupt_read ; call slave_send {{ 0xf0 }} movlw 240 movwf slave_send__data call slave_send ; call interrupt_read {{ 0 , 0xd4 }} clrf interrupt_read__desired movlw 212 movwf interrupt_read__test_number call interrupt_read ; Set / clear interrupt enable bit only : ; call slave_send {{ 0xf7 }} movlw 247 movwf slave_send__data call slave_send ; call interrupt_read {{ 2 , 0xd5 }} movlw 2 movwf interrupt_read__desired movlw 213 movwf interrupt_read__test_number call interrupt_read ; call slave_send {{ 0xf6 }} movlw 246 movwf slave_send__data call slave_send ; call interrupt_read {{ 0 , 0xd6 }} clrf interrupt_read__desired movlw 214 movwf interrupt_read__test_number call interrupt_read ; call slave_send {{ 0xf2 }} movlw 242 movwf slave_send__data call slave_send ; call interrupt_read {{ 2 , 0xd7 }} movlw 2 movwf interrupt_read__desired movlw 215 movwf interrupt_read__test_number call interrupt_read ; call slave_send {{ 0xf0 }} movlw 240 movwf slave_send__data call slave_send ; call interrupt_read {{ 0 , 0xd8 }} clrf interrupt_read__desired movlw 216 movwf interrupt_read__test_number call interrupt_read ; Now set both the interrupt enable and pending bit . ; This must trigger an interrupt . ; call slave_send {{ 0xf3 }} movlw 243 movwf slave_send__data call slave_send ; `count_down counter 3 ...' start movlw 3 movwf interrupt_test__counter interrupt_test__799_loop: ; call delay {{ }} call delay decfsz interrupt_test__counter,f goto interrupt_test__799_loop interrupt_test__799_done: ; `count_down counter 3 ...' end ; if { rx_slave_pin } start ; expression=`{ rx_slave_pin }' exp_delay=0 true_delay=3 false_delay=0 true_size=5 false_size=0 btfss rx_slave_pin__byte,rx_slave_pin__bit goto label802__0end ; if { rx_slave_pin } body start ; No interrupt detected : ; call master_fail {{ interrupt_string , 0xd9 }} movlw LOW interrupt_string+1 movwf master_fail__test_name movlw 217 movwf master_fail__test_number call master_fail ; if { rx_slave_pin } body end label802__0end: ; if exp=`rx_slave_pin' empty false ; Other expression=`{ rx_slave_pin }' delay=-1 ; if { rx_slave_pin } end ; The interrupt enable bit should cleared as a side effect ; of triggering the interrupt : ; call interrupt_read {{ 1 , 0xda }} movlw 1 movwf interrupt_read__desired movlw 218 movwf interrupt_read__test_number call interrupt_read ; Clear the interrupt pending bit : ; call slave_send {{ 0xf0 }} movlw 240 movwf slave_send__data call slave_send ; call interrupt_read {{ 0 , 0xdb }} clrf interrupt_read__desired movlw 219 movwf interrupt_read__test_number call interrupt_read ; procedure interrupt_test end retlw 0 ; procedure interrupt_read start interrupt_read: interrupt_read__variables__base equ global__variables__bank0+42 interrupt_read__bytes__base equ interrupt_read__variables__base+0 interrupt_read__bits__base equ interrupt_read__variables__base+3 interrupt_read__total__bytes equ 3 interrupt_read__desired equ interrupt_read__bytes__base+0 interrupt_read__test_number equ interrupt_read__bytes__base+1 ; This procedure will verify that the interrupt bits match < desired > . interrupt_read__temp equ interrupt_read__bytes__base+2 ; call slave_send {{ 0xef }} movlw 239 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf interrupt_read__temp ; if { temp != desired } start subwf interrupt_read__desired,w ; expression=`{ temp != desired }' exp_delay=2 true_delay=4 false_delay=0 true_size=8 false_size=0 btfsc z___byte,z___bit goto label826__0end ; if { temp != desired } body start ; call master_octal {{ temp }} movf interrupt_read__temp,w movwf master_octal__number call master_octal ; call master_fail {{ interrupt_string , test_number }} movlw LOW interrupt_string+1 movwf master_fail__test_name movf interrupt_read__test_number,w movwf master_fail__test_number call master_fail ; if { temp != desired } body end label826__0end: ; if exp=` temp != desired ' empty false ; Other expression=`{ temp != desired }' delay=-1 ; if { temp != desired } end ; procedure interrupt_read end retlw 0 ; comment {The following procedures are used to communicate with the master :} ; procedure master_crlf start master_crlf: master_crlf__variables__base equ global__variables__bank0+45 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_fail start master_fail: master_fail__variables__base equ global__variables__bank0+45 master_fail__bytes__base equ master_fail__variables__base+0 master_fail__bits__base equ master_fail__variables__base+2 master_fail__total__bytes equ 2 master_fail__test_name equ master_fail__bytes__base+0 master_fail__test_number equ master_fail__bytes__base+1 ; This procedure will output ` fail ' followed by a carriage return ; and line feed . ; call master_string {{ fail_string }} movlw LOW fail_string+1 movwf master_string__message call master_string ; call master_string {{ test_name }} movf master_fail__test_name,w movwf master_string__message call master_string ; call master_octal {{ test_number }} movf master_fail__test_number,w movwf master_octal__number call master_octal ; call master_crlf {{ }} call master_crlf ; procedure master_fail end retlw 0 ; procedure master_get start master_get: master_get__variables__base equ global__variables__bank0+47 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 2 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_octal start master_octal: master_octal__variables__base equ global__variables__bank0+48 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__876byte0 equ master_octal__bytes__base+1 master_octal__877byte0 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__876byte0 rrf master_octal__876byte0,f rrf master_octal__876byte0,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__877byte0 rrf master_octal__877byte0,f rrf master_octal__877byte0,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+50 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 32 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_send start slave_send: slave_send__variables__base equ global__variables__bank0+51 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 16 movwf send_byte__mask call send_byte ; procedure slave_send end retlw 0 ; comment {The last procedures do character sending and receiving :} ; procedure get_byte start get_byte: get_byte__variables__base equ global__variables__bank0+52 get_byte__bytes__base equ get_byte__variables__base+0 get_byte__bits__base equ get_byte__variables__base+5 get_byte__total__bytes equ 5 get_byte__933byte1 equ get_byte__bytes__base+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 < portb > 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 portb & mask != 0 ...' start get_byte__915while__continue: movf portb,w andwf get_byte__mask,w ; expression=` portb & 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__915while__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 label917__0end ; if { count = 0 } body start ; return 0xfc movlw 252 movwf get_byte__0return__byte retlw 0 ; if { count = 0 } body end label917__0end: ; if exp=` count = 0 ' empty false ; Other expression=`{ count = 0 }' delay=-1 ; if { count = 0 } end ; call delay {{ }} call delay goto get_byte__915while__continue ; if exp=` portb & mask != 0 ' false goto ; Other expression=` portb & mask != 0 ' delay=-1 get_byte__915while__break: ; `while portb & 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 : ; 1 cycle : ; char := 0 clrf get_byte__char ; 2 cycles for loop setup : ; 1 + 2 = 3 ; nop extra_instructions_per_bit - 3 ; Delay 9 cycles movlw 2 movwf get_byte__933byte1 get_byte__933delay0: decfsz get_byte__933byte1,f goto get_byte__933delay0 nop nop ; `count_down count 8 ...' start movlw 8 movwf get_byte__count get_byte__934_loop: ; call delay {{ }} call delay ; 2 cycles : ; char := char >> 1 bcf c___byte,c___bit rrf get_byte__char,f ; 3 cycles : ; if { portb & mask != 0 } start movf portb,w andwf get_byte__mask,w ; expression=`{ portb & mask != 0 }' exp_delay=2 true_delay=1 false_delay=0 true_size=1 false_size=0 btfss z___byte,z___bit ; if { portb & mask != 0 } body start ; char @ 7 := 1 ; Select char @ 7 get_byte__char__941select0 equ get_byte__char+0 get_byte__char__941select0__byte equ get_byte__char+0 get_byte__char__941select0__bit equ 7 bsf get_byte__char__941select0__byte,get_byte__char__941select0__bit ; if { portb & mask != 0 } body end ; if exp=` portb & mask != 0 ' false skip delay=4 ; Other expression=`{ portb & mask != 0 }' delay=4 ; if { portb & mask != 0 } end ; call delay {{ }} call delay ; call delay {{ }} call delay ; 3 cycles at end of loop : ; 2 + 3 + 3 = 8 ; nop extra_instructions_per_bit - 8 ; Delay 4 cycles nop nop nop nop decfsz get_byte__count,f goto get_byte__934_loop get_byte__934_done: ; `count_down count 8 ...' end ; Skip over 2 / 3 of the stop bit : ; call delay {{ }} call delay ; 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+57 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 < portb > . send_byte__count equ send_byte__bytes__base+2 send_byte__mark equ send_byte__bytes__base+3 ; Send the start bit : ; 3 cycles : ; mark := mask ^ space movlw 255 xorwf send_byte__mask,w movwf send_byte__mark ; 1 cycles < mark is already in W > : ; portb := mark movwf portb ; call delay {{ }} call delay ; call delay {{ }} call delay ; call delay {{ }} call delay ; 2 cycles for loop setup : ; 3 + 1 + 2 = 6 ; nop extra_instructions_per_bit - 6 ; Delay 6 cycles nop nop nop nop nop nop ; Send the data : ; `count_down count 8 ...' start movlw 8 movwf send_byte__count send_byte__980_loop: ; 5 cycles : ; if { char @ 0 } start ; Alias variable for select char @ 0 send_byte__char__982select0 equ send_byte__char+0 send_byte__char__982select0__byte equ send_byte__char+0 send_byte__char__982select0__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__982select0__byte,send_byte__char__982select0__bit ; if { char @ 0 } body start ; portb := space movlw 255 ; 1 instructions found for sharing btfss send_byte__char__982select0__byte,send_byte__char__982select0__bit ; else body start ; portb := 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 portb ; if { char @ 0 } end ; 2 cycles : ; 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 ; 3 cycles at end of loop : ; 5 + 2 + 3 = 10 ; nop extra_instructions_per_bit - 10 ; Delay 2 cycles nop nop decfsz send_byte__count,f goto send_byte__980_loop send_byte__980_done: ; `count_down count 8 ...' end ; Send the stop bit : ; 1 cycle to finish off previous loop : ; nop 1 ; Delay 1 cycles nop ; 2 cycles : ; portb := space movlw 255 movwf portb ; call delay {{ }} call delay ; call delay {{ }} call delay ; call delay {{ }} call delay ; 4 cycles for call / return : ; 4 cycles for two arguments : ; 2 + 4 + 4 = 10 ; nop extra_instructions_per_bit - 10 ; Delay 2 cycles nop nop ; procedure send_byte end retlw 0 ; procedure master_send start master_send: master_send__variables__base equ global__variables__bank0+61 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_string start master_string: master_string__variables__base equ global__variables__bank0+62 master_string__bytes__base equ master_string__variables__base+0 master_string__bits__base equ master_string__variables__base+3 master_string__total__bytes equ 3 master_string__message equ master_string__bytes__base+0 ; This procedure will output < message > to the master . master_string__size equ master_string__bytes__base+1 master_string__index equ master_string__bytes__base+2 ; index := 0 clrf master_string__index ; `while index < message . size ...' start master_string__1030while__continue: clrf pclath___register movf master_string__message,w call string___fetch subwf master_string__index,w ; expression=` index < message . size ' exp_delay=4 true_delay=7 false_delay=2 true_size=8 false_size=1 btfsc c___byte,c___bit goto master_string__1030while__break ; call master_send {{ message ~~ {{ index }} }} incf master_string__index,w addwf master_string__message,w clrf pclath___register call string___fetch movwf master_send__character call master_send ; index := index + 1 incf master_string__index,f goto master_string__1030while__continue ; if exp=` index < message . size ' false goto ; Other expression=` index < message . size ' delay=-1 master_string__1030while__break: ; `while index < message . size ...' end ; call master_send {{ sp }} movlw 32 movwf master_send__character call master_send ; procedure master_string end retlw 0 ; procedure delay start ; optimize 0 delay: delay__variables__base equ global__variables__bank0+65 delay__bytes__base equ delay__variables__base+0 delay__bits__base equ delay__variables__base+1 delay__total__bytes equ 1 delay__1037byte1 equ delay__bytes__base+0 ; arguments_none ; uniform_delay delay_instructions ; Uniform delay remaining = 339 Accumulated Delay = 0 ; Uniform delay remaining = 339 Accumulated Delay = 0 ; Delay 1 third of a bit : ; Uniform delay remaining = 339 Accumulated Delay = 0 ; Uniform delay remaining = 339 Accumulated Delay = 0 ; Soak up remaining 339 cycles ; Delay 339 cycles movlw 112 movwf delay__1037byte1 delay__1037delay0: decfsz delay__1037byte1,f goto delay__1037delay0 nop nop ; procedure delay end retlw 0 ; optimize 1 ; Register bank 0 used 66 bytes of 96 available bytes ; Register bank 1 used 0 bytes of 80 available bytes ; Register bank 2 used 0 bytes of 48 available bytes ; Register bank 3 used 0 bytes of 0 available bytes end