radix dec global__variables__bank0 equ 12 global__variables__bank1 equ 255 global__bit__variables__bank0 equ 70 global__bit__variables__bank1 equ 255 indf___register equ 0 pcl___register equ 2 c___byte equ 3 c___bit equ 0 z___byte equ 3 z___bit equ 2 rp0___byte equ 3 rp0___bit equ 5 rp1___byte equ 3 rp1___bit equ 6 irp___byte equ 3 irp___bit equ 7 trisa___register equ 0x85 trisb___register equ 0x86 fsr___register equ 4 pclath___register equ 10 org 0 start: nop nop nop goto skip___interrupt interrupt___vector: retfie skip___interrupt: ; Initialize TRIS registers movlw 233 ; Switch from register bank 0 to register bank 1 (which contains trisa___register) bsf rp0___byte,rp0___bit ; Register bank is now 1 movwf trisa___register clrf pclath___register ; Switch from register bank 1 to register bank 0 bcf rp0___byte,rp0___bit ; Register bank is now 0 goto main ; comment ############################################################################# ; comment {} ; comment {Copyright < c > 1999 - 2001 by Wayne C . Gramlich .} ; comment {All rights reserved .} ; comment {} ; comment {Permission to use , copy , modify , distribute , and sell this software} ; comment {for any purpose is hereby granted without fee provided that the above} ; comment {copyright notice and this permission are retained . The author makes} ; comment {no representations about the suitability of this software for any purpose .} ; comment {It is provided { as is } without express or implied warranty .} ; comment {} ; comment {This is a test harness for testing the Motor2 RoboBrick . See :} ; comment {} ; comment {http : / / web . gramlich . net / projects / robobricks / motor2 / index . html} ; comment {} ; comment {for more details .} ; comment {} ; comment ############################################################################# ; processor pic16f84 cp = off dp = off pwrte = disabled wdte = disabled fosc = xt ; 16377=0x3ff9 8199=0x2007 __config 16377 configuration___address equ 8199 ; constant clock_rate 4000000 clock_rate equ 4000000 ; constant instruction_rate clock_rate / 4 instruction_rate equ 1000000 ; constant baud_rate 2400 baud_rate equ 2400 ; constant instructions_per_bit instruction_rate / baud_rate instructions_per_bit equ 416 ; constant delays_per_bit 3 delays_per_bit equ 3 ; constant instructions_per_delay instructions_per_bit / delays_per_bit instructions_per_delay equ 138 ; constant sp 32 sp equ 32 ; constant cr 13 cr equ 13 ; constant lf 10 lf equ 10 ; comment {Some bit definitions :} ; constant rx_slave_bit 0 rx_slave_bit equ 0 ; constant tx_slave_bit 1 tx_slave_bit equ 1 ; constant tx_master_bit 2 tx_master_bit equ 2 ; constant rx_master_bit 3 rx_master_bit equ 3 ; constant rx_slave_mask 1 << rx_slave_bit rx_slave_mask equ 1 ; constant tx_slave_mask 1 << tx_slave_bit tx_slave_mask equ 2 ; constant rx_master_mask 1 << rx_master_bit rx_master_mask equ 8 ; constant tx_master_mask 1 << tx_master_bit tx_master_mask equ 4 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 porta equ 5 tx_master_pin__byte equ 5 tx_master_pin__bit equ 2 rx_master_pin__byte equ 5 rx_master_pin__bit equ 3 tx_slave_pin__byte equ 5 tx_slave_pin__bit equ 1 rx_slave_pin__byte equ 5 rx_slave_pin__bit equ 0 heart__byte equ 5 heart__bit equ 4 ; constant space 0xff space equ 255 ; constant buffer_size 5 buffer_size equ 5 ; string_constants Start string___fetch: movwf pcl___register ; clock_string = 0s'Clk' clock_string___string equ 0 clock_string: addwf pcl___register,f ; Length = 3 retlw 3 ; `Clk' retlw 67 retlw 108 retlw 107 ; common_string = 0s'Common' common_string___string equ 5 common_string: addwf pcl___register,f ; Length = 6 retlw 6 ; `Common' retlw 67 retlw 111 retlw 109 retlw 109 retlw 111 retlw 110 ; direction_string = 0s'Dir' direction_string___string equ 13 direction_string: addwf pcl___register,f ; Length = 3 retlw 3 ; `Dir' retlw 68 retlw 105 retlw 114 ; done_string = 0s'Done' done_string___string equ 18 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 24 fail_string: addwf pcl___register,f ; Length = 4 retlw 4 ; `Fail' retlw 70 retlw 97 retlw 105 retlw 108 ; failsafe_string = 0s'F/S' failsafe_string___string equ 30 failsafe_string: addwf pcl___register,f ; Length = 3 retlw 3 ; `F/S' retlw 70 retlw 47 retlw 83 ; hello_string = 0s'Motor2_Test' hello_string___string equ 35 hello_string: addwf pcl___register,f ; Length = 11 retlw 11 ; `Motor2_Test' retlw 77 retlw 111 retlw 116 retlw 111 retlw 114 retlw 50 retlw 95 retlw 84 retlw 101 retlw 115 retlw 116 ; mode_string = 0s'Mode' mode_string___string equ 48 mode_string: addwf pcl___register,f ; Length = 4 retlw 4 ; `Mode' retlw 77 retlw 111 retlw 100 retlw 101 ; mode_dir_string = 0s'M/D' mode_dir_string___string equ 54 mode_dir_string: addwf pcl___register,f ; Length = 3 retlw 3 ; `M/D' retlw 77 retlw 47 retlw 68 ; motor_string = 0s'Motor' motor_string___string equ 59 motor_string: addwf pcl___register,f ; Length = 5 retlw 5 ; `Motor' retlw 77 retlw 111 retlw 116 retlw 111 retlw 114 ; ramps = 0 , 1 , 0x10 , 0x80 , 0xff ramps___string equ 66 ramps: addwf pcl___register,f ; Length = 5 retlw 5 ; 0 retlw 0 ; 1 retlw 1 ; 0x10 retlw 16 ; 0x80 retlw 128 ; 0xff retlw 255 ; ramp_string = 0s'Ramp' ramp_string___string equ 73 ramp_string: addwf pcl___register,f ; Length = 4 retlw 4 ; `Ramp' retlw 82 retlw 97 retlw 109 retlw 112 ; scaler_string = 0s'Scaler' scaler_string___string equ 79 scaler_string: addwf pcl___register,f ; Length = 6 retlw 6 ; `Scaler' retlw 83 retlw 99 retlw 97 retlw 108 retlw 101 retlw 114 ; speeds = 0x10 , 0x20 , 0x40 , 0x80 , 0xff , 0 speeds___string equ 87 speeds: addwf pcl___register,f ; Length = 6 retlw 6 ; 0x10 retlw 16 ; 0x20 retlw 32 ; 0x40 retlw 64 ; 0x80 retlw 128 ; 0xff retlw 255 ; 0 retlw 0 ; speed_string = 0s'Speed' speed_string___string equ 95 speed_string: addwf pcl___register,f ; Length = 5 retlw 5 ; `Speed' retlw 83 retlw 112 retlw 101 retlw 101 retlw 100 ; 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__106byte0 equ main__bytes__base+9 main__134byte0 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__94loop__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 and103__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 label103__1false label103__1true: and103__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__106byte0 rlf main__106byte0,f rlf main__106byte0,w andlw 248 addwf main__char,w addlw 208 movwf main__number ; if { 0c'0' <= char && char < {{ 0c'9' + 1 }} } body end goto label103__1end label103__1false: and103__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 label107__0false label107__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 label107__0end label107__0false: movlw 119 subwf main__char,w ; expression=`{ char = 0c'w' }' exp_delay=2 true_delay=-1 false_delay=-1 true_size=37 false_size=56 btfss z___byte,z___bit goto label118__0false label118__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__133while__continue: movlw 5 subwf main__index,w ; expression=` index < buffer_size ' exp_delay=2 true_delay=9 false_delay=2 true_size=10 false_size=1 btfsc c___byte,c___bit goto main__133while__break ; buffer ~~ {{ index }} := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf main__134byte0 movlw LOW main__buffer addwf main__index,w movwf fsr___register movf main__134byte0,w movwf indf___register ; index := index + 1 incf main__index,f goto main__133while__continue ; if exp=` index < buffer_size ' false goto ; Other expression=` index < buffer_size ' delay=-1 main__133while__break: ; `while index < buffer_size ...' end ; index := 0 clrf main__index ; `while index < buffer_size ...' start main__139while__continue: movlw 5 subwf main__index,w ; expression=` index < buffer_size ' exp_delay=2 true_delay=7 false_delay=2 true_size=8 false_size=1 btfsc c___byte,c___bit goto main__139while__break ; call master_octal {{ buffer ~~ {{ index }} }} movlw LOW main__buffer addwf main__index,w movwf fsr___register movf indf___register,w movwf master_octal__number call master_octal ; index := index + 1 incf main__index,f goto main__139while__continue ; if exp=` index < buffer_size ' false goto ; Other expression=` index < buffer_size ' delay=-1 main__139while__break: ; `while index < buffer_size ...' end ; Terminate the output list ; call master_crlf {{ }} call master_crlf ; else_if { char = 0c'w' } body end goto label118__0end label118__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=39 btfss z___byte,z___bit goto label146__0false label146__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 slave_id8 {{ }} call slave_id8 ; Get the next 8 bytes of random numbers : ; call slave_id8 {{ }} call slave_id8 ; Get the next 8 bytes of random numbers : ; call slave_id8 {{ }} call slave_id8 ; Get the slave brick name : ; call slave_id_string {{ }} call slave_id_string ; Get the vendor name : ; call slave_id_string {{ }} call slave_id_string ; else_if { char = 0c'i' } body end goto label146__0end label146__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=29 btfss z___byte,z___bit goto label169__0false label169__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 label169__0end label169__0false: movlw 99 subwf main__char,w ; expression=`{ char = 0c'c' }' exp_delay=2 true_delay=-1 false_delay=-1 true_size=5 false_size=19 btfss z___byte,z___bit goto label174__0false label174__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 {{ }} call clock_adjust ; else_if { char = 0c'c' } body end goto label174__0end label174__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 label179__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 label179__0end: ; if exp=` char != 0xfc ' empty false ; Other expression=`{ char != 0xfc }' delay=-1 ; if exp=` char = 0c'c' ' generic label174__0end: ; Other expression=`{ char = 0c'c' }' delay=-1 ; if exp=` char = 0c't' ' generic label169__0end: ; Other expression=`{ char = 0c't' }' delay=-1 ; if exp=` char = 0c'i' ' generic label146__0end: ; Other expression=`{ char = 0c'i' }' delay=-1 ; if exp=` char = 0c'w' ' generic label118__0end: ; Other expression=`{ char = 0c'w' }' delay=-1 ; if exp=` char = 0c's' ' generic label107__0end: ; Other expression=`{ char = 0c's' }' delay=-1 ; if exp=`char < {{ 0c'9' + 1 }}' generic label103__1end: ; Other expression=`char < {{ 0c'9' + 1 }}' delay=-1 ; if exp=`0c'0' <= char' false goto ; Other expression=`0c'0' <= char' delay=-1 and103__0end: ; if { 0c'0' <= char && char < {{ 0c'9' + 1 }} } end goto main__94loop__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+5 clock_adjust__total__bytes equ 5 clock_adjust__252byte0 equ clock_adjust__bytes__base+4 ; arguments_none ; This procedure will adjust the clock to the slave . ; The null pulse that comes back is supposed to be 9 bits long . ; At 4 Mhz = 1 instruction per microsecond , 9 bits is 9 / 2400 = ; 3 . 75 ms . The count loop below is 7 instruction long . 3 . 75 / . 007 = ; 536 = 0x217 . So we want our timer loop to get as close to 0x217 ; as possible . clock_adjust__error equ clock_adjust__bytes__base+0 clock_adjust__error_minimum equ clock_adjust__bytes__base+1 clock_adjust__high equ clock_adjust__bytes__base+2 clock_adjust__low equ clock_adjust__bytes__base+3 ; call master_string {{ clock_string }} movlw LOW clock_string+1 movwf master_string__message call master_string ; error := 0xff movlw 255 movwf clock_adjust__error ; error_minimum := 0xf0 movlw 240 movwf clock_adjust__error_minimum ; `while error > error_minimum ...' start clock_adjust__221while__continue: movf clock_adjust__error,w subwf clock_adjust__error_minimum,w ; expression=` error > error_minimum ' exp_delay=2 true_delay=1 false_delay=2 true_size=55 false_size=1 btfsc c___byte,c___bit goto clock_adjust__221while__break ; 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__227while__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__227while__continue goto clock_adjust__227while__break ; if exp=`rx_slave_pin' true goto small true clock_adjust__227while__break: ; `while rx_slave_pin ...' end ; `while ! rx_slave_pin ...' start clock_adjust__230while__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__230while__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__230while__continue ; if exp=`rx_slave_pin' true goto ; Other expression=`rx_slave_pin' delay=-1 clock_adjust__230while__break: ; `while ! rx_slave_pin ...' end ; If high is less than 2 , things are probably pretty broken . ; We ' ll try a little fix here , but we are probably pretty ; screwed up . ; if { high < 2 } start movlw 2 subwf clock_adjust__high,w ; expression=`{ high < 2 }' exp_delay=2 true_delay=1 false_delay=0 true_size=1 false_size=0 btfss c___byte,c___bit ; if { high < 2 } body start ; low := 0 clrf clock_adjust__low ; if { high < 2 } body end ; if exp=` high < 2 ' false skip delay=4 ; Other expression=`{ high < 2 }' delay=4 ; if { high < 2 } end ; call master_octal {{ low }} movf clock_adjust__low,w movwf master_octal__number call master_octal ; Now think about adjusting clock . ; if { low > 0x17 } start movlw 24 subwf clock_adjust__low,w ; expression=`{ low > 0x17 }' exp_delay=2 true_delay=4 false_delay=-1 true_size=6 false_size=15 btfsc c___byte,c___bit goto label245__0true label245__0false: movlw 23 subwf clock_adjust__low,w ; expression=`{ low < 0x17 }' exp_delay=2 true_delay=6 false_delay=2 true_size=8 false_size=2 btfss c___byte,c___bit goto label250__0true label250__0false: ; else body start ; error := 0 clrf clock_adjust__error ; error_minimum := 0 clrf clock_adjust__error_minimum ; else body end goto label250__0end label250__0true: ; else_if { low < 0x17 } body start ; Slave clock is too fast < i . e . pulse too short . > ; error := 0x17 - low movlw 23 movwf clock_adjust__252byte0 movf clock_adjust__low,w subwf clock_adjust__252byte0,w movwf clock_adjust__error ; Decrement clock : ; call slave_send {{ 0xf8 }} movlw 248 movwf slave_send__data call slave_send ; else_if { low < 0x17 } body end ; if exp=` low < 0x17 ' generic label250__0end: ; Other expression=`{ low < 0x17 }' delay=-1 goto label245__0end label245__0true: ; if { low > 0x17 } body start ; Slave clock is too slow < i . e . pulse too long . > ; error := low - 0x17 movlw 233 addwf clock_adjust__low,w movwf clock_adjust__error ; Increment clock : ; call slave_send {{ 0xf9 }} movlw 249 movwf slave_send__data call slave_send ; if { low > 0x17 } body end ; if exp=` low > 0x17 ' generic label245__0end: ; Other expression=`{ low > 0x17 }' delay=-1 ; if { low > 0x17 } end ; if { error < error_minimum } start movf clock_adjust__error_minimum,w subwf clock_adjust__error,w ; expression=`{ error < error_minimum }' exp_delay=2 true_delay=3 false_delay=0 true_size=3 false_size=0 btfsc c___byte,c___bit goto label259__0end ; 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 ; if { error < error_minimum } body end label259__0end: ; if exp=` error < error_minimum ' empty false ; Other expression=`{ error < error_minimum }' delay=-1 ; if { error < error_minimum } end goto clock_adjust__221while__continue ; if exp=` error > error_minimum ' false goto ; Other expression=` error > error_minimum ' delay=-1 clock_adjust__221while__break: ; `while error > error_minimum ...' end ; call master_crlf {{ }} call master_crlf ; procedure clock_adjust end retlw 0 ; procedure test start test: test__variables__base equ global__variables__bank0+15 test__bytes__base equ test__variables__base+0 test__bits__base equ test__variables__base+13 test__total__bytes equ 13 test__404byte0 equ test__bytes__base+12 test__401byte0 equ test__bytes__base+12 ; arguments_none ; This procedure will test the Motor2 RoboBrick : test__counter1 equ test__bytes__base+0 test__counter2 equ test__bytes__base+1 test__direction equ test__bytes__base+2 test__failsafe equ test__bytes__base+3 test__mode equ test__bytes__base+4 test__motor equ test__bytes__base+5 test__prescaler equ test__bytes__base+6 test__ramp equ test__bytes__base+7 test__ramp_index equ test__bytes__base+8 test__speed_index equ test__bytes__base+9 test__speed equ test__bytes__base+10 test__temp equ test__bytes__base+11 ; Adjust the clock : ; call clock_adjust {{ }} call clock_adjust ; Verify that the common commands are working : ; call common_test {{ }} call common_test ; Reset everything : ; call slave_send {{ 0xa4 }} movlw 164 movwf slave_send__data call slave_send ; Test with prescaler : ; call master_string {{ scaler_string }} movlw LOW scaler_string+1 movwf master_string__message call master_string ; call master_crlf {{ }} call master_crlf ; prescaler := 0 clrf test__prescaler ; `while prescaler <= 7 ...' start test__299while__continue: movlw 8 subwf test__prescaler,w ; expression=` prescaler <= 7 ' exp_delay=2 true_delay=1 false_delay=2 true_size=24 false_size=1 btfsc c___byte,c___bit goto test__299while__break ; Set Prescaler : ; call slave_send {{ 0x90 | prescaler }} movlw 144 iorwf test__prescaler,w movwf slave_send__data call slave_send ; Read prescaler : ; call slave_send {{ 0x99 }} movlw 153 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__temp ; if { temp != prescaler } start subwf test__prescaler,w ; expression=`{ temp != prescaler }' exp_delay=2 true_delay=4 false_delay=0 true_size=8 false_size=0 btfsc z___byte,z___bit goto label307__0end ; if { temp != prescaler } body start ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_fail {{ scaler_string , 0x30 }} movlw LOW scaler_string+1 movwf master_fail__test_name movlw 48 movwf master_fail__test_number call master_fail ; if { temp != prescaler } body end label307__0end: ; if exp=` temp != prescaler ' empty false ; Other expression=`{ temp != prescaler }' delay=-1 ; if { temp != prescaler } end ; prescaler := prescaler + 1 incf test__prescaler,f goto test__299while__continue ; if exp=` prescaler <= 7 ' false goto ; Other expression=` prescaler <= 7 ' delay=-1 test__299while__break: ; `while prescaler <= 7 ...' end ; Reset the prescaler to 5 : ; call slave_send {{ 0x95 }} movlw 149 movwf slave_send__data call slave_send ; Test failsafe : ; call master_string {{ failsafe_string }} movlw LOW failsafe_string+1 movwf master_string__message call master_string ; call master_crlf {{ }} call master_crlf ; Set failsafe : ; call slave_send {{ 0x82 }} movlw 130 movwf slave_send__data call slave_send ; call slave_send {{ 0xff }} movlw 255 movwf slave_send__data call slave_send ; Set speed : ; call slave_send {{ 0x3c }} movlw 60 movwf slave_send__data call slave_send ; Wait for failsafe to trigger : ; failsafe := 0xff movlw 255 movwf test__failsafe ; `while failsafe != 0 ...' start test__329while__continue: movf test__failsafe,w ; expression=` failsafe != 0 ' exp_delay=1 true_delay=4 false_delay=2 true_size=7 false_size=1 btfsc z___byte,z___bit goto test__329while__break ; call slave_send {{ 0xa1 }} movlw 161 movwf slave_send__data call slave_send ; failsafe := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__failsafe goto test__329while__continue ; if exp=` failsafe != 0 ' false goto ; Other expression=` failsafe != 0 ' delay=-1 test__329while__break: ; `while failsafe != 0 ...' end ; Read failsafe error counter : ; call slave_send {{ 0xa0 }} movlw 160 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__temp ; if { temp != 1 } start decf test__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 label337__0end ; if { temp != 1 } body start ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_fail {{ failsafe_string , 0x37 }} movlw LOW failsafe_string+1 movwf master_fail__test_name movlw 55 movwf master_fail__test_number call master_fail ; if { temp != 1 } body end label337__0end: ; if exp=` temp != 1 ' empty false ; Other expression=`{ temp != 1 }' delay=-1 ; if { temp != 1 } end ; Verify that failsafe error counter reset : ; call slave_send {{ 0xa0 }} movlw 160 movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__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 label345__0end ; if { temp != 0 } body start ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_fail {{ failsafe_string , 0x38 }} movlw LOW failsafe_string+1 movwf master_fail__test_name movlw 56 movwf master_fail__test_number call master_fail ; if { temp != 0 } body end label345__0end: ; if exp=` temp != 0 ' empty false ; Other expression=`{ temp != 0 }' delay=-1 ; if { temp != 0 } end ; Reset everything : ; call slave_send {{ 0xa4 }} movlw 164 movwf slave_send__data call slave_send ; Do some ramp testing : ; ramp_index := 0 clrf test__ramp_index ; `while ramp_index < ramps . size ...' start test__355while__continue: movlw 5 subwf test__ramp_index,w ; expression=` ramp_index < ramps . size ' exp_delay=2 true_delay=1 false_delay=2 true_size=232 false_size=1 btfsc c___byte,c___bit goto test__355while__break ; call master_send < 0c'R' > ; ramp := ramps ~~ {{ ramp_index }} incf test__ramp_index,w clrf pclath___register call ramps movwf test__ramp ; mode := 0 clrf test__mode ; `while mode < 2 ...' start test__359while__continue: movlw 2 subwf test__mode,w ; expression=` mode < 2 ' exp_delay=2 true_delay=1 false_delay=2 true_size=221 false_size=1 btfsc c___byte,c___bit goto test__359while__break ; call master_send < 0c'M' > ; direction := 0 clrf test__direction ; `while direction < 2 ...' start test__362while__continue: movlw 2 subwf test__direction,w ; expression=` direction < 2 ' exp_delay=2 true_delay=1 false_delay=2 true_size=214 false_size=1 btfsc c___byte,c___bit goto test__362while__break ; call master_send < 0c'D' > ; motor := 0 clrf test__motor ; `while motor < 2 ...' start test__365while__continue: movlw 2 subwf test__motor,w ; expression=` motor < 2 ' exp_delay=2 true_delay=1 false_delay=2 true_size=207 false_size=1 btfsc c___byte,c___bit goto test__365while__break ; call master_send < 0c'S' > ; call master_string {{ ramp_string }} movlw LOW ramp_string+1 movwf master_string__message call master_string ; call master_octal {{ ramp }} movf test__ramp,w movwf master_octal__number call master_octal ; call master_string {{ mode_string }} movlw LOW mode_string+1 movwf master_string__message call master_string ; call master_octal {{ mode }} movf test__mode,w movwf master_octal__number call master_octal ; call master_string {{ direction_string }} movlw LOW direction_string+1 movwf master_string__message call master_string ; call master_octal {{ direction }} movf test__direction,w movwf master_octal__number call master_octal ; call master_string {{ motor_string }} movlw LOW motor_string+1 movwf master_string__message call master_string ; call master_octal {{ motor }} movf test__motor,w movwf master_octal__number call master_octal ; call master_crlf {{ }} call master_crlf ; Set the mode : ; call slave_send {{ 0x88 | {{ mode << 1 }} | motor }} bcf c___byte,c___bit rlf test__mode,w iorwf test__motor,w iorlw 136 movwf slave_send__data call slave_send ; Set the ramp : ; call slave_send {{ 0x80 | motor }} movlw 128 iorwf test__motor,w movwf slave_send__data call slave_send ; call slave_send {{ ramp }} movf test__ramp,w movwf slave_send__data call slave_send ; Verify the ramp : ; call slave_send {{ 0x9e | motor }} movlw 158 iorwf test__motor,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 != ramp } start subwf test__ramp,w ; expression=`{ temp != ramp }' exp_delay=2 true_delay=4 false_delay=0 true_size=8 false_size=0 btfsc z___byte,z___bit goto label387__0end ; if { temp != ramp } body start ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_fail {{ ramp_string , 0x31 }} movlw LOW ramp_string+1 movwf master_fail__test_name movlw 49 movwf master_fail__test_number call master_fail ; if { temp != ramp } body end label387__0end: ; if exp=` temp != ramp ' empty false ; Other expression=`{ temp != ramp }' delay=-1 ; if { temp != ramp } end ; Do a complete speed check when the ramp is zero : ; if { ramp = 0 } start movf test__ramp,w ; expression=`{ ramp = 0 }' exp_delay=1 true_delay=-1 false_delay=-1 true_size=88 false_size=56 btfss z___byte,z___bit goto label393__0false label393__0true: ; if { ramp = 0 } body start ; Ramp motor up through speeds : ; speed := 0 clrf test__speed ; `while speed < 255 ...' start test__396while__continue: movlw 255 subwf test__speed,w ; expression=` speed < 255 ' exp_delay=2 true_delay=1 false_delay=2 true_size=47 false_size=1 btfsc c___byte,c___bit goto test__396while__break ; Set speed : ; temp := {{ direction << 1 }} | motor bcf c___byte,c___bit rlf test__direction,w iorwf test__motor,w movwf test__temp ; if { speed & 0xf = 0 } start movlw 15 andwf test__speed,w ; expression=`{ speed & 0xf = 0 }' exp_delay=2 true_delay=3 false_delay=5 true_size=5 false_size=7 btfss z___byte,z___bit goto label399__0false label399__0true: ; if { speed & 0xf = 0 } body start ; Set high : ; call slave_send {{ {{ speed >> 2 }} | temp }} rrf test__speed,w movwf test__401byte0 rrf test__401byte0,w andlw 63 iorwf test__temp,w ; 2 instructions found for sharing goto label399__0end label399__0false: ; else body start ; Set low : ; call slave_send {{ 0x40 | {{ speed << 2 }} & 0x3c | temp }} rlf test__speed,w movwf test__404byte0 rlf test__404byte0,w andlw 60 iorwf test__temp,w iorlw 64 ; 2 instructions found for sharing ; if exp=` speed & 0xf = 0 ' generic label399__0end: ; Other expression=`{ speed & 0xf = 0 }' delay=-1 ; 2 shared instructions follow movwf slave_send__data call slave_send ; if { speed & 0xf = 0 } end ; Read and verify speed : ; call slave_send {{ 0x9a | motor }} movlw 154 iorwf test__motor,w movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__temp ; if { speed != temp } start movf test__speed,w subwf test__temp,w ; expression=`{ speed != temp }' exp_delay=2 true_delay=5 false_delay=0 true_size=11 false_size=0 btfsc z___byte,z___bit goto label410__0end ; if { speed != temp } body start ; call master_octal {{ speed }} movf test__speed,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 {{ speed_string , 0x32 }} movlw LOW speed_string+1 movwf master_fail__test_name movlw 50 movwf master_fail__test_number call master_fail ; if { speed != temp } body end label410__0end: ; if exp=` speed != temp ' empty false ; Other expression=`{ speed != temp }' delay=-1 ; if { speed != temp } end ; speed := speed + 1 incf test__speed,f goto test__396while__continue ; if exp=` speed < 255 ' false goto ; Other expression=` speed < 255 ' delay=-1 test__396while__break: ; `while speed < 255 ...' end ; Ramp motor down through speeds : ; `while speed != 0 ...' start test__419while__continue: movf test__speed,w ; expression=` speed != 0 ' exp_delay=1 true_delay=1 false_delay=2 true_size=33 false_size=1 btfsc z___byte,z___bit goto test__419while__break ; Set speed : ; call slave_send {{ 0x84 | {{ direction << 1 }} | motor }} bcf c___byte,c___bit rlf test__direction,w iorwf test__motor,w iorlw 132 movwf slave_send__data call slave_send ; call slave_send {{ speed }} movf test__speed,w movwf slave_send__data call slave_send ; Read and verify speed : ; call slave_send {{ 0x9a | motor }} movlw 154 iorwf test__motor,w movwf slave_send__data call slave_send ; temp := slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf test__temp ; if { speed != temp } start movf test__speed,w subwf test__temp,w ; expression=`{ speed != temp }' exp_delay=2 true_delay=5 false_delay=0 true_size=11 false_size=0 btfsc z___byte,z___bit goto label427__0end ; if { speed != temp } body start ; call master_octal {{ speed }} movf test__speed,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 {{ speed_string , 0x33 }} movlw LOW speed_string+1 movwf master_fail__test_name movlw 51 movwf master_fail__test_number call master_fail ; if { speed != temp } body end label427__0end: ; if exp=` speed != temp ' empty false ; Other expression=`{ speed != temp }' delay=-1 ; if { speed != temp } end ; speed := speed - 1 decf test__speed,f goto test__419while__continue ; if exp=` speed != 0 ' false goto ; Other expression=` speed != 0 ' delay=-1 test__419while__break: ; `while speed != 0 ...' end ; if { ramp = 0 } body end goto label393__0end label393__0false: ; else body start ; Do ramp testing : ; speed_index := 0 clrf test__speed_index ; `while speed_index < speeds . size ...' start test__437while__continue: movlw 6 subwf test__speed_index,w ; expression=` speed_index < speeds . size ' exp_delay=2 true_delay=1 false_delay=2 true_size=51 false_size=1 btfsc c___byte,c___bit goto test__437while__break ; call master_send < 0c'S' > ; Set the speed : ; speed := speeds ~~ {{ speed_index }} incf test__speed_index,w clrf pclath___register call speeds movwf test__speed ; call slave_send {{ 0x84 | {{ direction << 1 }} | motor }} bcf c___byte,c___bit rlf test__direction,w iorwf test__motor,w iorlw 132 movwf slave_send__data call slave_send ; call slave_send {{ speed }} movf test__speed,w movwf slave_send__data call slave_send ; Now wait for the speed to ramp up : ; temp := speed - 1 decf test__speed,w movwf test__temp ; `count_down counter1 8 ...' start movlw 8 movwf test__counter1 test__446_loop: ; `count_down counter2 255 ...' start movlw 255 movwf test__counter2 test__447_loop: ; Read actual speed : ; if { temp != speed } start movf test__temp,w subwf test__speed,w ; expression=`{ temp != speed }' exp_delay=2 true_delay=3 false_delay=0 true_size=7 false_size=0 btfsc z___byte,z___bit goto label449__0end ; if { temp != speed } body start ; call slave_send {{ 0xa2 | motor }} movlw 162 iorwf test__motor,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 != speed } body end label449__0end: ; if exp=` temp != speed ' empty false ; Other expression=`{ temp != speed }' delay=-1 ; if { temp != speed } end decfsz test__counter2,f goto test__447_loop test__447_done: ; `count_down counter2 255 ...' end decfsz test__counter1,f goto test__446_loop test__446_done: ; `count_down counter1 8 ...' end ; See whether we timed out : ; if { temp != speed } start movf test__temp,w subwf test__speed,w ; expression=`{ temp != speed }' exp_delay=2 true_delay=5 false_delay=0 true_size=11 false_size=0 btfsc z___byte,z___bit goto label457__0end ; if { temp != speed } body start ; call master_octal {{ temp }} movf test__temp,w movwf master_octal__number call master_octal ; call master_octal {{ speed }} movf test__speed,w movwf master_octal__number call master_octal ; call master_fail {{ ramp_string , 0x34 }} movlw LOW ramp_string+1 movwf master_fail__test_name movlw 52 movwf master_fail__test_number call master_fail ; if { temp != speed } body end label457__0end: ; if exp=` temp != speed ' empty false ; Other expression=`{ temp != speed }' delay=-1 ; if { temp != speed } end ; speed_index := speed_index + 1 incf test__speed_index,f goto test__437while__continue ; if exp=` speed_index < speeds . size ' false goto ; Other expression=` speed_index < speeds . size ' delay=-1 test__437while__break: ; `while speed_index < speeds . size ...' end ; else body end ; if exp=` ramp = 0 ' generic label393__0end: ; Other expression=`{ ramp = 0 }' delay=-1 ; if { ramp = 0 } end ; motor := motor + 1 incf test__motor,f goto test__365while__continue ; if exp=` motor < 2 ' false goto ; Other expression=` motor < 2 ' delay=-1 test__365while__break: ; `while motor < 2 ...' end ; direction := direction + 1 incf test__direction,f goto test__362while__continue ; if exp=` direction < 2 ' false goto ; Other expression=` direction < 2 ' delay=-1 test__362while__break: ; `while direction < 2 ...' end ; mode := mode + 1 incf test__mode,f goto test__359while__continue ; if exp=` mode < 2 ' false goto ; Other expression=` mode < 2 ' delay=-1 test__359while__break: ; `while mode < 2 ...' end ; ramp_index := ramp_index + 1 incf test__ramp_index,f goto test__355while__continue ; if exp=` ramp_index < ramps . size ' false goto ; Other expression=` ramp_index < ramps . size ' delay=-1 test__355while__break: ; `while ramp_index < ramps . size ...' end ; Reset everything : ; call slave_send {{ 0xa4 }} movlw 164 movwf slave_send__data call slave_send ; Announce end of test run : ; 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 ; 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+28 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__527byte0 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 {{ 14 , 0xc2 }} movlw 14 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__527byte0 movlw 2 subwf common_test__527byte0,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 label527__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 label527__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 label533__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 label533__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 label545__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 label545__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+30 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 label557__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 label557__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+32 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__570_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__570_loop common_test_id_bytes8__570_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+33 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__583_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__583_loop common_test_id_string__583_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+34 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 following procedures are used to communicate with the master :} ; procedure master_crlf start master_crlf: master_crlf__variables__base equ global__variables__bank0+35 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+35 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+37 master_get__bytes__base equ master_get__variables__base+0 master_get__bits__base equ master_get__variables__base+1 master_get__total__bytes equ 1 ; arguments_none master_get__0return__byte equ master_get__bytes__base+0 ; This procedure will get the next byte or return 0xfc if ; no byte is forthcoming . ; return get_byte {{ rx_master_mask }} movlw 8 movwf get_byte__mask call get_byte movf get_byte__0return__byte,w movwf master_get__0return__byte retlw 0 ; procedure master_get end ; procedure master_octal start master_octal: master_octal__variables__base equ global__variables__bank0+38 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__643byte0 equ master_octal__bytes__base+1 master_octal__644byte0 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__643byte0 rrf master_octal__643byte0,f rrf master_octal__643byte0,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__644byte0 rrf master_octal__644byte0,f rrf master_octal__644byte0,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+40 slave_get__bytes__base equ slave_get__variables__base+0 slave_get__bits__base equ slave_get__variables__base+1 slave_get__total__bytes equ 1 ; arguments_none slave_get__0return__byte equ slave_get__bytes__base+0 ; This procedure will get a byte from the slave or return 0xfc ; if no byte is forthcoming . ; return get_byte {{ rx_slave_mask }} movlw 1 movwf get_byte__mask call get_byte movf get_byte__0return__byte,w movwf slave_get__0return__byte retlw 0 ; procedure slave_get end ; procedure slave_id8 start slave_id8: slave_id8__variables__base equ global__variables__bank0+41 slave_id8__bytes__base equ slave_id8__variables__base+0 slave_id8__bits__base equ slave_id8__variables__base+1 slave_id8__total__bytes equ 1 ; arguments_none ; This procedure will print out the next 8 bytes of data from ; the slave RoboBrick id bytes . slave_id8__counter equ slave_id8__bytes__base+0 ; `count_down counter 8 ...' start movlw 8 movwf slave_id8__counter slave_id8__668_loop: ; call master_octal {{ slave_id_next {{ }} }} call slave_id_next movf slave_id_next__0return__byte,w movwf master_octal__number call master_octal decfsz slave_id8__counter,f goto slave_id8__668_loop slave_id8__668_done: ; `count_down counter 8 ...' end ; call master_crlf {{ }} call master_crlf ; procedure slave_id8 end retlw 0 ; procedure slave_id_next start slave_id_next: slave_id_next__variables__base equ global__variables__bank0+42 slave_id_next__bytes__base equ slave_id_next__variables__base+0 slave_id_next__bits__base equ slave_id_next__variables__base+1 slave_id_next__total__bytes equ 1 ; arguments_none slave_id_next__0return__byte equ slave_id_next__bytes__base+0 ; This procedure will return the next byte from the id bytes . ; call slave_send {{ 0xfc }} movlw 252 movwf slave_send__data call slave_send ; return slave_get {{ }} call slave_get movf slave_get__0return__byte,w movwf slave_id_next__0return__byte retlw 0 ; procedure slave_id_next end ; procedure slave_id_string start slave_id_string: slave_id_string__variables__base equ global__variables__bank0+43 slave_id_string__bytes__base equ slave_id_string__variables__base+0 slave_id_string__bits__base equ slave_id_string__variables__base+1 slave_id_string__total__bytes equ 1 ; arguments_none ; This procedure will return the string for the id bytes . slave_id_string__size equ slave_id_string__bytes__base+0 ; size := slave_id_next {{ }} call slave_id_next movf slave_id_next__0return__byte,w movwf slave_id_string__size ; call master_octal {{ size }} movwf master_octal__number call master_octal ; `count_down size size ...' start movf slave_id_string__size,w movwf slave_id_string__size slave_id_string__694_loop: ; call master_send {{ slave_id_next {{ }} }} call slave_id_next movf slave_id_next__0return__byte,w movwf master_send__character call master_send decfsz slave_id_string__size,f goto slave_id_string__694_loop slave_id_string__694_done: ; `count_down size size ...' end ; call master_crlf {{ }} call master_crlf ; procedure slave_id_string end retlw 0 ; procedure slave_send start slave_send: slave_send__variables__base equ global__variables__bank0+44 slave_send__bytes__base equ slave_send__variables__base+0 slave_send__bits__base equ slave_send__variables__base+1 slave_send__total__bytes equ 1 slave_send__data equ slave_send__bytes__base+0 ; This procedure will send one byte of < data > to the slave . ; call send_byte {{ data , tx_slave_mask }} movf slave_send__data,w movwf send_byte__char movlw 2 movwf send_byte__mask call send_byte ; procedure slave_send end retlw 0 ; comment {The last procedures do character sending and receiving :} ; procedure get_byte start get_byte: get_byte__variables__base equ global__variables__bank0+45 get_byte__bytes__base equ get_byte__variables__base+0 get_byte__bits__base equ get_byte__variables__base+4 get_byte__total__bytes equ 4 get_byte__mask equ get_byte__bytes__base+0 get_byte__0return__byte equ get_byte__bytes__base+1 ; Get an 8 - bit byte from < mask > bit of < porta > and return it . ; If no character shows up in a while 0xfc is returned . get_byte__count equ get_byte__bytes__base+2 get_byte__char equ get_byte__bytes__base+3 ; Wait until a start bit arrives : ; count := 0 clrf get_byte__count ; `while porta & mask != 0 ...' start get_byte__723while__continue: movf porta,w andwf get_byte__mask,w ; expression=` porta & mask != 0 ' exp_delay=2 true_delay=1 false_delay=2 true_size=9 false_size=1 btfsc z___byte,z___bit goto get_byte__723while__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 label725__0end ; if { count = 0 } body start ; return 0xfc movlw 252 movwf get_byte__0return__byte retlw 0 ; if { count = 0 } body end label725__0end: ; if exp=` count = 0 ' empty false ; Other expression=`{ count = 0 }' delay=-1 ; if { count = 0 } end ; call delay {{ }} call delay goto get_byte__723while__continue ; if exp=` porta & mask != 0 ' false goto ; Other expression=` porta & mask != 0 ' delay=-1 get_byte__723while__break: ; `while porta & mask != 0 ...' end ; Skip over the start bit : ; call delay {{ }} call delay ; call delay {{ }} call delay ; call delay {{ }} call delay ; Sample in the middle third of each data bit : ; char := 0 clrf get_byte__char ; `count_down count 8 ...' start movlw 8 movwf get_byte__count get_byte__738_loop: ; call delay {{ }} call delay ; char := char >> 1 bcf c___byte,c___bit rrf get_byte__char,f ; if { porta & mask != 0 } start movf porta,w andwf get_byte__mask,w ; expression=`{ porta & mask != 0 }' exp_delay=2 true_delay=2 false_delay=0 true_size=2 false_size=0 btfsc z___byte,z___bit goto label741__0end ; if { porta & mask != 0 } body start ; char := char | 0x80 movlw 128 iorwf get_byte__char,f ; if { porta & mask != 0 } body end label741__0end: ; if exp=` porta & mask != 0 ' empty false ; Other expression=`{ porta & mask != 0 }' delay=-1 ; if { porta & mask != 0 } end ; call delay {{ }} call delay ; call delay {{ }} call delay decfsz get_byte__count,f goto get_byte__738_loop get_byte__738_done: ; `count_down count 8 ...' end ; Skip over 1 / 3 of the stop bit : ; call delay {{ }} call delay ; return char movf get_byte__char,w movwf get_byte__0return__byte retlw 0 ; procedure get_byte end ; procedure send_byte start send_byte: send_byte__variables__base equ global__variables__bank0+49 send_byte__bytes__base equ send_byte__variables__base+0 send_byte__bits__base equ send_byte__variables__base+4 send_byte__total__bytes equ 4 send_byte__char equ send_byte__bytes__base+0 send_byte__mask equ send_byte__bytes__base+1 ; Send < char > to < mask > bit of < porta > . send_byte__count equ send_byte__bytes__base+2 send_byte__mark equ send_byte__bytes__base+3 ; Send the start bit : ; mark := mask ^ space movlw 255 xorwf send_byte__mask,w movwf send_byte__mark ; porta := mark movwf porta ; call delay {{ }} call delay ; call delay {{ }} call delay ; call delay {{ }} call delay ; Send the data : ; `count_down count 8 ...' start movlw 8 movwf send_byte__count send_byte__773_loop: ; if { char @ 0 } start ; Alias variable for select char @ 0 send_byte__char__774select0 equ send_byte__char+0 send_byte__char__774select0__byte equ send_byte__char+0 send_byte__char__774select0__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__774select0__byte,send_byte__char__774select0__bit ; if { char @ 0 } body start ; porta := space movlw 255 ; 1 instructions found for sharing btfss send_byte__char__774select0__byte,send_byte__char__774select0__bit ; else body start ; porta := mark movf send_byte__mark,w ; 1 instructions found for sharing ; if exp=` char @ 0 ' single true and false skip delay=4 ; Other expression=`{ char @ 0 }' delay=4 ; 1 shared instructions follow movwf porta ; if { char @ 0 } end ; char := char >> 1 bcf c___byte,c___bit rrf send_byte__char,f ; call delay {{ }} call delay ; call delay {{ }} call delay ; call delay {{ }} call delay decfsz send_byte__count,f goto send_byte__773_loop send_byte__773_done: ; `count_down count 8 ...' end ; Send the stop bit : ; porta := space movlw 255 movwf porta ; call delay {{ }} call delay ; call delay {{ }} call delay ; call delay {{ }} call delay ; procedure send_byte end retlw 0 ; procedure master_send start master_send: master_send__variables__base equ global__variables__bank0+53 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+54 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__811while__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__811while__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__811while__continue ; if exp=` index < message . size ' false goto ; Other expression=` index < message . size ' delay=-1 master_string__811while__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+57 delay__bytes__base equ delay__variables__base+0 delay__bits__base equ delay__variables__base+1 delay__total__bytes equ 1 delay__818byte1 equ delay__bytes__base+0 ; arguments_none ; uniform_delay instructions_per_delay ; Uniform delay remaining = 134 Accumulated Delay = 0 ; Uniform delay remaining = 134 Accumulated Delay = 0 ; Delay 1 third of a bit : ; Uniform delay remaining = 134 Accumulated Delay = 0 ; Uniform delay remaining = 134 Accumulated Delay = 0 ; Soak up remaining 134 cycles ; Delay 134 cycles movlw 44 movwf delay__818byte1 delay__818delay0: decfsz delay__818byte1,f goto delay__818delay0 nop ; procedure delay end retlw 0 ; optimize 1 ; Register bank 0 used 58 bytes of 68 available bytes ; Register bank 1 used 0 bytes of 0 available bytes end