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 103 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 LED10 RoboBrick . See :} ; comment {} ; comment {http : / / web . gramlich . net / projects / robobricks / led10 / 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 3 buffer_size equ 3 ; 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 ; done_string = 0s'Done' done_string___string equ 8 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 14 fail_string: addwf pcl___register,f ; Length = 4 retlw 4 ; `Fail' retlw 70 retlw 97 retlw 105 retlw 108 ; hello_string = 0s'BIROD2_Test' hello_string___string equ 20 hello_string: addwf pcl___register,f ; Length = 11 retlw 11 ; `BIROD2_Test' retlw 66 retlw 73 retlw 82 retlw 79 retlw 68 retlw 50 retlw 95 retlw 84 retlw 101 retlw 115 retlw 116 ; input_string = 0s'Input' input_string___string equ 33 input_string: addwf pcl___register,f ; Length = 5 retlw 5 ; `Input' retlw 73 retlw 110 retlw 112 retlw 117 retlw 116 ; interrupt_string = 0s'Interrupt' interrupt_string___string equ 40 interrupt_string: addwf pcl___register,f ; Length = 9 retlw 9 ; `Interrupt' retlw 73 retlw 110 retlw 116 retlw 101 retlw 114 retlw 114 retlw 117 retlw 112 retlw 116 ; enable_string = 0s'Enable and Alternate' enable_string___string equ 51 enable_string: addwf pcl___register,f ; Length = 20 retlw 20 ; `Enable and Alternate' retlw 69 retlw 110 retlw 97 retlw 98 retlw 108 retlw 101 retlw 32 retlw 97 retlw 110 retlw 100 retlw 32 retlw 65 retlw 108 retlw 116 retlw 101 retlw 114 retlw 110 retlw 97 retlw 116 retlw 101 ; read_string = 0s'Read' read_string___string equ 73 read_string: addwf pcl___register,f ; Length = 4 retlw 4 ; `Read' retlw 82 retlw 101 retlw 97 retlw 100 ; register_string = 0s'Register' register_string___string equ 79 register_string: addwf pcl___register,f ; Length = 8 retlw 8 ; `Register' retlw 82 retlw 101 retlw 103 retlw 105 retlw 115 retlw 116 retlw 101 retlw 114 ; test_string = 0s'Test' test_string___string equ 89 test_string: addwf pcl___register,f ; Length = 4 retlw 4 ; `Test' retlw 84 retlw 101 retlw 115 retlw 116 ; string__constants End temp equ global__variables__bank0+0 ; procedure main start main: main__variables__base equ global__variables__bank0+1 main__bytes__base equ main__variables__base+0 main__bits__base equ main__variables__base+7 main__total__bytes equ 7 main__119byte0 equ main__bytes__base+6 main__147byte0 equ main__bytes__base+6 ; arguments_none ; Read a byte . main__buffer equ main__bytes__base+0 main__char equ main__bytes__base+3 main__index equ main__bytes__base+4 main__number equ main__bytes__base+5 ; 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__107loop__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=127 false_size=1 btfss c___byte,c___bit goto and116__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=111 btfsc c___byte,c___bit goto label116__1false label116__1true: and116__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__119byte0 rlf main__119byte0,f rlf main__119byte0,w andlw 248 addwf main__char,w addlw 208 movwf main__number ; if { 0c'0' <= char && char < {{ 0c'9' + 1 }} } body end goto label116__1end label116__1false: and116__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=98 btfss z___byte,z___bit goto label120__0false label120__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 label120__0end label120__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=54 btfss z___byte,z___bit goto label131__0false label131__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__146while__continue: movlw 3 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__146while__break ; buffer ~~ {{ index }} := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf main__147byte0 movlw LOW main__buffer addwf main__index,w movwf fsr___register movf main__147byte0,w bcf irp___register,irp___bit movwf indf___register ; index := index + 1 incf main__index,f goto main__146while__continue ; if exp=` index < buffer_size ' false goto ; Other expression=` index < buffer_size ' delay=-1 main__146while__break: ; `while index < buffer_size ...' end ; index := 0 clrf main__index ; `while index < buffer_size ...' start main__152while__continue: movlw 3 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__152while__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__152while__continue ; if exp=` index < buffer_size ' false goto ; Other expression=` index < buffer_size ' delay=-1 main__152while__break: ; `while index < buffer_size ...' end ; Terminate the output list ; call master_crlf {{ }} call master_crlf ; else_if { char = 0c'w' } body end goto label131__0end label131__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=37 btfss z___byte,z___bit goto label159__0false label159__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 label159__0end label159__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=27 btfss z___byte,z___bit goto label182__0false label182__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 label182__0end label182__0false: movlw 99 subwf main__char,w ; expression=`{ char = 0c'c' }' exp_delay=2 true_delay=-2 false_delay=-2 true_size=7 false_size=14 btfss z___byte,z___bit goto label187__0false label187__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 ; 1 instructions found for sharing goto label187__0end label187__0false: ; else 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 ; 1 instructions found for sharing ; if exp=` char = 0c'c' ' generic label187__0end: ; Other expression=`{ char = 0c'c' }' delay=-1 ; 1 shared instructions follow clrf main__number ; if exp=` char = 0c't' ' generic label182__0end: ; Other expression=`{ char = 0c't' }' delay=-1 ; if exp=` char = 0c'i' ' generic label159__0end: ; Other expression=`{ char = 0c'i' }' delay=-1 ; if exp=` char = 0c'w' ' generic label131__0end: ; Other expression=`{ char = 0c'w' }' delay=-1 ; if exp=` char = 0c's' ' generic label120__0end: ; Other expression=`{ char = 0c's' }' delay=-1 ; if exp=`char < {{ 0c'9' + 1 }}' generic label116__1end: ; Other expression=`char < {{ 0c'9' + 1 }}' delay=-1 ; if exp=`0c'0' <= char' false goto ; Other expression=`0c'0' <= char' delay=-1 and116__0end: ; if { 0c'0' <= char && char < {{ 0c'9' + 1 }} } end goto main__107loop__forever ; loop_forever ... end ; procedure main end ; procedure clock_adjust start clock_adjust: clock_adjust__variables__base equ global__variables__bank0+8 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__228byte0 equ clock_adjust__bytes__base+8 clock_adjust__270byte0 equ clock_adjust__bytes__base+8 clock_adjust__280byte0 equ clock_adjust__bytes__base+8 clock_adjust__284byte0 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__228byte0 movf clock_adjust__adjust,w subwf clock_adjust__228byte0,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__239loop__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__250while__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__250while__continue goto clock_adjust__250while__break ; if exp=`rx_slave_pin' true goto small true clock_adjust__250while__break: ; `while rx_slave_pin ...' end ; `while ! rx_slave_pin ...' start clock_adjust__253while__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__253while__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__253while__continue ; if exp=`rx_slave_pin' true goto ; Other expression=`rx_slave_pin' delay=-1 clock_adjust__253while__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 label267__0true label267__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 label271__0true label271__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 label277__0true label277__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 label281__0true label281__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 label281__0end label281__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__284byte0 movf clock_adjust__low,w subwf clock_adjust__284byte0,w movwf clock_adjust__error ; else_if { low < target } body end ; if exp=` low < target ' generic label281__0end: ; Other expression=`{ low < target }' delay=-1 goto label277__0end label277__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__280byte0 movf clock_adjust__target,w subwf clock_adjust__280byte0,w movwf clock_adjust__error ; if { low > target } body end ; if exp=` low > target ' generic label277__0end: ; Other expression=`{ low > target }' delay=-1 ; if { low > target } end ; else body end goto label271__0end label271__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 label271__0end: ; Other expression=`{ high < iterations_high }' delay=-1 goto label267__0end label267__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__270byte0 movf clock_adjust__target,w subwf clock_adjust__270byte0,w movwf clock_adjust__error ; if { high > iterations_high } body end ; if exp=` high > iterations_high ' generic label267__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 label299__0false label299__0true: ; if { error = error_minimum } body start ; call master_crlf {{ }} call master_crlf ; return retlw 0 ; if { error = error_minimum } body end goto label299__0end label299__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 label302__0true label302__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 label307__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 label307__0end: ; if exp=`z' empty false ; Other expression=`{ z }' delay=-1 ; if { z } end ; else body end goto label302__0end label302__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 label302__0end: ; Other expression=`{ error < error_minimum }' delay=-1 ; if exp=` error = error_minimum ' generic label299__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__239loop__forever ; loop_forever ... end ; procedure clock_adjust end ; procedure test start test: test__variables__base equ global__variables__bank0+17 test__bytes__base equ test__variables__base+0 test__bits__base equ test__variables__base+0 test__total__bytes equ 0 ; arguments_none ; This procedure will test the Shaft2 RoboBrick : ; Verify that the common commands are working : ; call common_test {{ }} call common_test ; Verify that we can interrupt : ; call interrupt_test {{ }} call interrupt_test ; Let ' s go test some registers : ; 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 ; Enable / Complement : ; call test_register {{ 0x10 , 3 , 0x30 }} movlw 16 movwf test_register__set_command movlw 3 movwf test_register__read_command movlw 48 movwf test_register__error call test_register ; High / Low : ; call test_register {{ 0x20 , 4 , 0x31 }} movlw 32 movwf test_register__set_command movlw 4 movwf test_register__read_command movlw 49 movwf test_register__error call test_register ; Raising / Falling : ; call test_register {{ 0x30 , 5 , 0x32 }} movlw 48 movwf test_register__set_command movlw 5 movwf test_register__read_command movlw 50 movwf test_register__error call test_register ; Now test that the BIROD ' s are actually working : ; call test_inputs {{ 0 }} clrf test_inputs__pattern call test_inputs ; call test_inputs {{ 1 }} movlw 1 movwf test_inputs__pattern call test_inputs ; call test_inputs {{ 2 }} movlw 2 movwf test_inputs__pattern call test_inputs ; call test_inputs {{ 3 }} movlw 3 movwf test_inputs__pattern call test_inputs ; Test for interrupts : ; 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 ; High interrupt : ; call test_interrupt {{ 0 , 1 , 0x20 , 4 }} clrf test_interrupt__start_pattern movlw 1 movwf test_interrupt__end_pattern movlw 32 movwf test_interrupt__set_command movlw 4 movwf test_interrupt__set_bits call test_interrupt ; Low interrupt : ; call test_interrupt {{ 1 , 0 , 0x20 , 1 }} movlw 1 movwf test_interrupt__start_pattern clrf test_interrupt__end_pattern movlw 32 movwf test_interrupt__set_command movlw 1 movwf test_interrupt__set_bits call test_interrupt ; Raising interrupt : ; call test_interrupt {{ 0 , 1 , 0x30 , 4 }} clrf test_interrupt__start_pattern movlw 1 movwf test_interrupt__end_pattern movlw 48 movwf test_interrupt__set_command movlw 4 movwf test_interrupt__set_bits call test_interrupt ; Falling interrupt : ; call test_interrupt {{ 1 , 0 , 0x30 , 1 }} movlw 1 movwf test_interrupt__start_pattern clrf test_interrupt__end_pattern movlw 48 movwf test_interrupt__set_command movlw 1 movwf test_interrupt__set_bits call test_interrupt ; Announce 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_inputs start test_inputs: test_inputs__variables__base equ global__variables__bank0+17 test_inputs__bytes__base equ test_inputs__variables__base+0 test_inputs__bits__base equ test_inputs__variables__base+10 test_inputs__total__bytes equ 10 test_inputs__396byte0 equ test_inputs__bytes__base+9 test_inputs__pattern equ test_inputs__bytes__base+0 ; This procedure will verify that the inputs can be set to pattern . test_inputs__sleep1 equ test_inputs__bytes__base+1 test_inputs__sleep2 equ test_inputs__bytes__base+2 test_inputs__counter equ test_inputs__bytes__base+3 test_inputs__test equ test_inputs__bytes__base+4 test_inputs__command equ test_inputs__bytes__base+5 test_inputs__mask equ test_inputs__bytes__base+6 test_inputs__masked_pattern equ test_inputs__bytes__base+7 test_inputs__alternate equ test_inputs__bytes__base+8 ; Enable the IROD ' s : ; call test_prompt {{ pattern }} movf test_inputs__pattern,w movwf test_prompt__pattern call test_prompt ; `count_down counter 8 ...' start movlw 8 movwf test_inputs__counter test_inputs__392_loop: ; Set the enable bits : ; test := counter - 1 decf test_inputs__counter,w movwf test_inputs__test ; mask := test & 3 movlw 3 andwf test_inputs__test,w movwf test_inputs__mask ; command := 0x10 | {{ mask << 2 }} rlf test_inputs__mask,w movwf test_inputs__396byte0 rlf test_inputs__396byte0,w andlw 252 iorlw 16 movwf test_inputs__command ; call slave_send {{ command }} movwf slave_send__data call slave_send ; masked_pattern := mask & pattern movf test_inputs__mask,w andwf test_inputs__pattern,w movwf test_inputs__masked_pattern ; Set the alternate bit : ; alternate := test >> 2 rrf test_inputs__test,w movwf test_inputs__alternate rrf test_inputs__alternate,w andlw 63 movwf test_inputs__alternate ; call slave_send {{ 6 | alternate }} movlw 6 iorwf test_inputs__alternate,w movwf slave_send__data call slave_send ; Announce test : ; call master_octal {{ test }} movf test_inputs__test,w movwf master_octal__number call master_octal ; call master_octal {{ masked_pattern }} movf test_inputs__masked_pattern,w movwf master_octal__number call master_octal ; call master_string {{ enable_string }} movlw LOW enable_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 ; Let the enables take hold : ; `count_down sleep1 50 ...' start movlw 50 movwf test_inputs__sleep1 test_inputs__412_loop: ; 30 * 1 / 3 bit delays = 10 bit delays : ; `count_down sleep2 30 ...' start movlw 30 movwf test_inputs__sleep2 test_inputs__414_loop: ; call delay {{ }} call delay decfsz test_inputs__sleep2,f goto test_inputs__414_loop test_inputs__414_done: ; `count_down sleep2 30 ...' end decfsz test_inputs__sleep1,f goto test_inputs__412_loop test_inputs__412_done: ; `count_down sleep1 50 ...' end ; Verify that the alternate bit is set : ; call slave_send {{ 3 }} movlw 3 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf temp ; if { temp != command & 0xf } start movlw 15 andwf test_inputs__command,w subwf temp,w ; expression=`{ temp != command & 0xf }' exp_delay=3 true_delay=4 false_delay=0 true_size=8 false_size=0 btfsc z___byte,z___bit goto label422__0end ; if { temp != command & 0xf } body start ; call master_octal {{ temp }} movf temp,w movwf master_octal__number call master_octal ; call master_fail {{ read_string , 0x40 }} movlw LOW read_string+1 movwf master_fail__test_name movlw 64 movwf master_fail__test_number call master_fail ; if { temp != command & 0xf } body end label422__0end: ; if exp=` temp != command & 0xf ' empty false ; Other expression=`{ temp != command & 0xf }' delay=-1 ; if { temp != command & 0xf } end ; Verify that the alternate bit is set : ; call slave_send {{ 2 }} movlw 2 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf temp ; if { temp != alternate } start subwf test_inputs__alternate,w ; expression=`{ temp != alternate }' exp_delay=2 true_delay=3 false_delay=0 true_size=5 false_size=0 btfsc z___byte,z___bit goto label430__0end ; if { temp != alternate } body start ; call master_octal < temp > ; call master_fail {{ read_string , 0x41 }} movlw LOW read_string+1 movwf master_fail__test_name movlw 65 movwf master_fail__test_number call master_fail ; if { temp != alternate } body end label430__0end: ; if exp=` temp != alternate ' empty false ; Other expression=`{ temp != alternate }' delay=-1 ; if { temp != alternate } end ; Regular read : ; call slave_send {{ 0 }} clrf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf temp ; if { temp != masked_pattern } start subwf test_inputs__masked_pattern,w ; expression=`{ temp != masked_pattern }' exp_delay=2 true_delay=4 false_delay=0 true_size=8 false_size=0 btfsc z___byte,z___bit goto label438__0end ; if { temp != masked_pattern } body start ; call master_octal {{ temp }} movf temp,w movwf master_octal__number call master_octal ; call master_fail {{ read_string , 0x42 }} movlw LOW read_string+1 movwf master_fail__test_name movlw 66 movwf master_fail__test_number call master_fail ; if { temp != masked_pattern } body end label438__0end: ; if exp=` temp != masked_pattern ' empty false ; Other expression=`{ temp != masked_pattern }' delay=-1 ; if { temp != masked_pattern } end ; Read raw : ; 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 temp ; if { temp != masked_pattern } start subwf test_inputs__masked_pattern,w ; expression=`{ temp != masked_pattern }' exp_delay=2 true_delay=4 false_delay=0 true_size=8 false_size=0 btfsc z___byte,z___bit goto label446__0end ; if { temp != masked_pattern } body start ; call master_octal {{ temp }} movf temp,w movwf master_octal__number call master_octal ; call master_fail {{ read_string , 0x43 }} movlw LOW read_string+1 movwf master_fail__test_name movlw 67 movwf master_fail__test_number call master_fail ; if { temp != masked_pattern } body end label446__0end: ; if exp=` temp != masked_pattern ' empty false ; Other expression=`{ temp != masked_pattern }' delay=-1 ; if { temp != masked_pattern } end ; Now test complement : ; call slave_send {{ command | 3 }} movlw 3 iorwf test_inputs__command,w movwf slave_send__data call slave_send ; call slave_send {{ 0 }} clrf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf temp ; if { temp ^ 3 != masked_pattern } start movlw 3 xorwf temp,w subwf test_inputs__masked_pattern,w ; expression=`{ temp ^ 3 != masked_pattern }' exp_delay=3 true_delay=4 false_delay=0 true_size=8 false_size=0 btfsc z___byte,z___bit goto label455__0end ; if { temp ^ 3 != masked_pattern } body start ; call master_octal {{ temp }} movf temp,w movwf master_octal__number call master_octal ; call master_fail {{ read_string , 0x44 }} movlw LOW read_string+1 movwf master_fail__test_name movlw 68 movwf master_fail__test_number call master_fail ; if { temp ^ 3 != masked_pattern } body end label455__0end: ; if exp=` temp ^ 3 != masked_pattern ' empty false ; Other expression=`{ temp ^ 3 != masked_pattern }' delay=-1 ; if { temp ^ 3 != masked_pattern } end ; Verify that raw did not change : ; 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 temp ; if { temp != masked_pattern } start subwf test_inputs__masked_pattern,w ; expression=`{ temp != masked_pattern }' exp_delay=2 true_delay=4 false_delay=0 true_size=8 false_size=0 btfsc z___byte,z___bit goto label463__0end ; if { temp != masked_pattern } body start ; call master_octal {{ temp }} movf temp,w movwf master_octal__number call master_octal ; call master_fail {{ read_string , 0x45 }} movlw LOW read_string+1 movwf master_fail__test_name movlw 69 movwf master_fail__test_number call master_fail ; if { temp != masked_pattern } body end label463__0end: ; if exp=` temp != masked_pattern ' empty false ; Other expression=`{ temp != masked_pattern }' delay=-1 ; if { temp != masked_pattern } end ; Reset complement bits : ; call slave_send {{ command }} movf test_inputs__command,w movwf slave_send__data call slave_send decfsz test_inputs__counter,f goto test_inputs__392_loop test_inputs__392_done: ; `count_down counter 8 ...' end ; procedure test_inputs end retlw 0 ; procedure test_prompt start test_prompt: test_prompt__variables__base equ global__variables__bank0+27 test_prompt__bytes__base equ test_prompt__variables__base+0 test_prompt__bits__base equ test_prompt__variables__base+2 test_prompt__total__bytes equ 2 test_prompt__pattern equ test_prompt__bytes__base+0 ; This procedure will prompt the user for pattern . test_prompt__character equ test_prompt__bytes__base+1 ; Enable both sensors : ; call slave_send {{ 0x1c }} movlw 28 movwf slave_send__data call slave_send ; Wait for the inputs to match : ; call master_crlf {{ }} call master_crlf ; temp := pattern + 1 incf test_prompt__pattern,w movwf temp ; `while temp != pattern ...' start test_prompt__487while__continue: movf temp,w subwf test_prompt__pattern,w ; expression=` temp != pattern ' exp_delay=2 true_delay=11 false_delay=2 true_size=28 false_size=1 btfsc z___byte,z___bit goto test_prompt__487while__break ; Display the pattern : ; call master_send {{ cr }} movlw 13 movwf master_send__character call master_send ; call master_string {{ input_string }} movlw LOW input_string+1 movwf master_string__message call master_string ; call test_show {{ pattern }} movf test_prompt__pattern,w movwf test_show__pattern call test_show ; call master_send {{ 0c'<' }} movlw 60 movwf master_send__character call master_send ; call test_show {{ temp }} movf temp,w movwf test_show__pattern call test_show ; call master_send {{ 0c'>' }} movlw 62 movwf master_send__character call master_send ; call master_send {{ 0c':' }} movlw 58 movwf master_send__character call master_send ; Read the raw inputs : ; 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 temp goto test_prompt__487while__continue ; if exp=` temp != pattern ' false goto ; Other expression=` temp != pattern ' delay=-1 test_prompt__487while__break: ; `while temp != pattern ...' end ; Print a carraige - return line - feed : ; call master_crlf {{ }} call master_crlf ; procedure test_prompt end retlw 0 ; procedure test_show start test_show: test_show__variables__base equ global__variables__bank0+29 test_show__bytes__base equ test_show__variables__base+0 test_show__bits__base equ test_show__variables__base+2 test_show__total__bytes equ 2 test_show__pattern equ test_show__bytes__base+0 ; This procedure will print out pattern : test_show__character equ test_show__bytes__base+1 ; if { pattern @ 1 } start ; Alias variable for select pattern @ 1 test_show__pattern__514select0 equ test_show__pattern+0 test_show__pattern__514select0__byte equ test_show__pattern+0 test_show__pattern__514select0__bit equ 1 ; expression=`{ pattern @ 1 }' exp_delay=0 true_delay=1 false_delay=1 true_size=1 false_size=1 btfsc test_show__pattern__514select0__byte,test_show__pattern__514select0__bit ; if { pattern @ 1 } body start ; character := 0c'1' movlw 49 ; 1 instructions found for sharing btfss test_show__pattern__514select0__byte,test_show__pattern__514select0__bit ; else body start ; character := 0c'0' movlw 48 ; 1 instructions found for sharing ; if exp=` pattern @ 1 ' single true and false skip delay=4 ; Other expression=`{ pattern @ 1 }' delay=4 ; 1 shared instructions follow movwf test_show__character ; if { pattern @ 1 } end ; call master_send {{ character }} movwf master_send__character call master_send ; if { pattern @ 0 } start ; Alias variable for select pattern @ 0 test_show__pattern__520select0 equ test_show__pattern+0 test_show__pattern__520select0__byte equ test_show__pattern+0 test_show__pattern__520select0__bit equ 0 ; expression=`{ pattern @ 0 }' exp_delay=0 true_delay=1 false_delay=1 true_size=1 false_size=1 btfsc test_show__pattern__520select0__byte,test_show__pattern__520select0__bit ; if { pattern @ 0 } body start ; character := 0c'1' movlw 49 ; 1 instructions found for sharing btfss test_show__pattern__520select0__byte,test_show__pattern__520select0__bit ; else body start ; character := 0c'0' movlw 48 ; 1 instructions found for sharing ; if exp=` pattern @ 0 ' single true and false skip delay=4 ; Other expression=`{ pattern @ 0 }' delay=4 ; 1 shared instructions follow movwf test_show__character ; if { pattern @ 0 } end ; call master_send {{ character }} movwf master_send__character call master_send ; procedure test_show end retlw 0 ; procedure test_interrupt start test_interrupt: test_interrupt__variables__base equ global__variables__bank0+31 test_interrupt__bytes__base equ test_interrupt__variables__base+0 test_interrupt__bits__base equ test_interrupt__variables__base+4 test_interrupt__total__bytes equ 4 test_interrupt__start_pattern equ test_interrupt__bytes__base+0 test_interrupt__end_pattern equ test_interrupt__bytes__base+1 test_interrupt__set_command equ test_interrupt__bytes__base+2 test_interrupt__set_bits equ test_interrupt__bytes__base+3 ; This procedure will validate that an interrupt occurs . ; call test_prompt {{ start_pattern }} movf test_interrupt__start_pattern,w movwf test_prompt__pattern call test_prompt ; Enable only one : ; call slave_send {{ 0x14 }} movlw 20 movwf slave_send__data call slave_send ; Enable the mask : ; call slave_send {{ set_command | set_bits }} movf test_interrupt__set_command,w iorwf test_interrupt__set_bits,w movwf slave_send__data call slave_send ; Let the tester know what we want : ; call test_show {{ end_pattern }} movf test_interrupt__end_pattern,w movwf test_show__pattern call test_show ; call master_send {{ 0c':' }} movlw 58 movwf master_send__character call master_send ; Wait for an interrupt : ; call test_interrupt_wait {{ }} call test_interrupt_wait ; Disable mask : ; call slave_send {{ set_command }} movf test_interrupt__set_command,w movwf slave_send__data call slave_send ; procedure test_interrupt end retlw 0 ; procedure test_interrupt_wait start test_interrupt_wait: test_interrupt_wait__variables__base equ global__variables__bank0+35 test_interrupt_wait__bytes__base equ test_interrupt_wait__variables__base+0 test_interrupt_wait__bits__base equ test_interrupt_wait__variables__base+0 test_interrupt_wait__total__bytes equ 0 ; arguments_none ; This procedure will test an interrupt : ; Now enable interrupts : ; call slave_send {{ 0xf2 }} movlw 242 movwf slave_send__data call slave_send ; Now wait for interrupt : ; `while rx_slave_pin ...' start test_interrupt_wait__566while__continue: ; expression=`rx_slave_pin' exp_delay=0 true_delay=1 false_delay=2 true_size=2 false_size=1 btfss rx_slave_pin__byte,rx_slave_pin__bit goto test_interrupt_wait__566while__break ; call delay {{ }} call delay goto test_interrupt_wait__566while__continue ; if exp=`rx_slave_pin' false goto ; Other expression=`rx_slave_pin' delay=-1 test_interrupt_wait__566while__break: ; `while rx_slave_pin ...' end ; call master_crlf {{ }} call master_crlf ; procedure test_interrupt_wait end retlw 0 ; procedure test_register start test_register: test_register__variables__base equ global__variables__bank0+35 test_register__bytes__base equ test_register__variables__base+0 test_register__bits__base equ test_register__variables__base+4 test_register__total__bytes equ 4 test_register__set_command equ test_register__bytes__base+0 test_register__read_command equ test_register__bytes__base+1 test_register__error equ test_register__bytes__base+2 ; This procedure will test the ability to set and read back a byte register : test_register__index equ test_register__bytes__base+3 ; index := 16 movlw 16 movwf test_register__index ; `while index != 0 ...' start test_register__583while__continue: movf test_register__index,w ; expression=` index != 0 ' exp_delay=1 true_delay=1 false_delay=2 true_size=27 false_size=1 btfsc z___byte,z___bit goto test_register__583while__break ; index := index - 1 decf test_register__index,f ; call slave_send {{ set_command | index }} movf test_register__set_command,w iorwf test_register__index,w movwf slave_send__data call slave_send ; call slave_send {{ read_command }} movf test_register__read_command,w movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf temp ; if { temp != index } start subwf test_register__index,w ; expression=`{ temp != index }' exp_delay=2 true_delay=5 false_delay=0 true_size=11 false_size=0 btfsc z___byte,z___bit goto label589__0end ; if { temp != index } body start ; call master_octal {{ index }} movf test_register__index,w movwf master_octal__number call master_octal ; call master_octal {{ temp }} movf temp,w movwf master_octal__number call master_octal ; call master_fail {{ register_string , error }} movlw LOW register_string+1 movwf master_fail__test_name movf test_register__error,w movwf master_fail__test_number call master_fail ; if { temp != index } body end label589__0end: ; if exp=` temp != index ' empty false ; Other expression=`{ temp != index }' delay=-1 ; if { temp != index } end goto test_register__583while__continue ; if exp=` index != 0 ' false goto ; Other expression=` index != 0 ' delay=-1 test_register__583while__break: ; `while index != 0 ...' end ; procedure test_register 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+39 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__642byte0 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 {{ 11 , 0xc2 }} movlw 11 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 {{ 1 , 0xc3 }} movlw 1 movwf 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__642byte0 movlw 2 subwf common_test__642byte0,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 label642__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 label642__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 label648__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 label648__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 label660__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 label660__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+41 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 label672__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 label672__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+43 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__685_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__685_loop common_test_id_bytes8__685_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+44 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__699_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__699_loop common_test_id_string__699_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+45 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+46 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__753_loop: ; call delay {{ }} call delay decfsz interrupt_test__counter,f goto interrupt_test__753_loop interrupt_test__753_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 label756__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 label756__0end: ; if exp=`rx_slave_pin' empty false ; Other expression=`{ rx_slave_pin }' delay=-1 ; if { rx_slave_pin } end ; Read the interrupt enable bit is cleared as a side effect ; of reading the bit . ; 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+47 interrupt_read__bytes__base equ interrupt_read__variables__base+0 interrupt_read__bits__base equ interrupt_read__variables__base+2 interrupt_read__total__bytes equ 2 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 > . ; 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 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 label778__0end ; if { temp != desired } body start ; call master_octal {{ temp }} movf 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 label778__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+49 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+49 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+51 master_get__bytes__base equ master_get__variables__base+0 master_get__bits__base equ master_get__variables__base+2 master_get__total__bytes equ 2 ; arguments_none master_get__0return__byte equ master_get__bytes__base+0 ; This procedure will get the next character from the master . master_get__character equ master_get__bytes__base+1 ; character := 0xfc movlw 252 movwf master_get__character ; `while character = 0xfc ...' start master_get__820while__continue: movlw 252 subwf master_get__character,w ; expression=` character = 0xfc ' exp_delay=2 true_delay=5 false_delay=2 true_size=6 false_size=1 btfss z___byte,z___bit goto master_get__820while__break ; character := get_byte {{ rx_master_mask }} movlw 2 movwf get_byte__mask call get_byte movf get_byte__0return__byte,w movwf master_get__character goto master_get__820while__continue ; if exp=` character = 0xfc ' false goto ; Other expression=` character = 0xfc ' delay=-1 master_get__820while__break: ; `while character = 0xfc ...' end ; return character movf master_get__character,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+53 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__833byte0 equ master_octal__bytes__base+1 master_octal__834byte0 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__833byte0 rrf master_octal__833byte0,f rrf master_octal__833byte0,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__834byte0 rrf master_octal__834byte0,f rrf master_octal__834byte0,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+55 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+56 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+57 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__890byte1 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__872while__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__872while__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 label874__0end ; if { count = 0 } body start ; return 0xfc movlw 252 movwf get_byte__0return__byte retlw 0 ; if { count = 0 } body end label874__0end: ; if exp=` count = 0 ' empty false ; Other expression=`{ count = 0 }' delay=-1 ; if { count = 0 } end ; call delay {{ }} call delay goto get_byte__872while__continue ; if exp=` portb & mask != 0 ' false goto ; Other expression=` portb & mask != 0 ' delay=-1 get_byte__872while__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 cylces for loop setup : ; 1 + 2 = 3 ; nop extra_instructions_per_bit - 3 ; Delay 9 cycles movlw 2 movwf get_byte__890byte1 get_byte__890delay0: decfsz get_byte__890byte1,f goto get_byte__890delay0 nop nop ; `count_down count 8 ...' start movlw 8 movwf get_byte__count get_byte__891_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__897select0 equ get_byte__char+0 get_byte__char__897select0__byte equ get_byte__char+0 get_byte__char__897select0__bit equ 7 bsf get_byte__char__897select0__byte,get_byte__char__897select0__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__891_loop get_byte__891_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+62 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 cylces 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__936_loop: ; 5 cylces : ; if { char @ 0 } start ; Alias variable for select char @ 0 send_byte__char__938select0 equ send_byte__char+0 send_byte__char__938select0__byte equ send_byte__char+0 send_byte__char__938select0__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__938select0__byte,send_byte__char__938select0__bit ; if { char @ 0 } body start ; portb := space movlw 255 ; 1 instructions found for sharing btfss send_byte__char__938select0__byte,send_byte__char__938select0__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__936_loop send_byte__936_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 to 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+66 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+67 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__986while__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__986while__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__986while__continue ; if exp=` index < message . size ' false goto ; Other expression=` index < message . size ' delay=-1 master_string__986while__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+70 delay__bytes__base equ delay__variables__base+0 delay__bits__base equ delay__variables__base+1 delay__total__bytes equ 1 delay__993byte1 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 ; Kick the dog : ; Uniform delay remaining = 339 Accumulated Delay = 0 ; watch_dog_reset clrwdt ; Uniform delay remaining = 338 Accumulated Delay = 1 ; Uniform delay remaining = 338 Accumulated Delay = 1 ; Soak up remaining 338 cycles ; Delay 338 cycles movlw 112 movwf delay__993byte1 delay__993delay0: decfsz delay__993byte1,f goto delay__993delay0 nop ; procedure delay end retlw 0 ; optimize 1 ; Register bank 0 used 71 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